[bug#58310] [PATCH] Add coq-mathcomp-analysis

[bug#58310] [PATCH] Add coq-mathcomp-analysis

[Garek Dyszel via Guix-patches via]

This patch set adds coq-mathcomp-analysis, but it does not build
correctly.

The build process for ocaml-elpi@1.16.5 is broken. I did, however, get
coq-mathcomp-analysis to successfully build when using an older
version: ocaml-elpi@1.15.2, which builds just fine.

To aid in debugging, I left the information for both versions of
ocaml-elpi in the commit which adds ocaml-elpi (ocaml-elpi@1.15.2's
info is commented out).

We will have to see whether it's possible to upgrade coq-elpi to
1.15.6 without breaking coq-mathcomp-hierarchy-builder. The same goes
for whether it's possible to upgrade coq-mathcomp-hierarchy-builder to
1.4.0 without breaking coq-mathcomp-analysis.

There is an unresolved warning from guix lint that says
"python-hatch@1.5.0: can be upgraded to 1.10.0". In fact, both
python-hatch and python-hatch-bootstrap are located in the same
repository, and the newest tag for hatch is hatch-v1.5.0. In this
case, guix lint is incorrect.

Let me know what you think!

[bug#58310] [PATCH 01/14] gnu: Add python-pprintpp.

[Garek Dyszel via Guix-patches via]

* gnu/packages/python-xyz.scm (python-pprintpp): New variable.
---
 gnu/packages/python-xyz.scm | 54 +++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/gnu/packages/python-xyz.scm b/gnu/packages/python-xyz.scm
index 8575d4a67e..439765dc4f 100644
--- a/gnu/packages/python-xyz.scm
+++ b/gnu/packages/python-xyz.scm
@@ -16688,6 +16688,60 @@ (define-public python-tabulate
 data in Python.")
     (license license:expat)))
 
+(define-public python-pprintpp
+  ;; Git version tags are inaccurate for this package; use the
+  ;; bare commit.
+  (let ((commit "7ede6da1f3062bbfb32ee04353d675a5bff185e0")
+        (revision "1"))
+    (package
+      (name "python-pprintpp")
+      (version (git-version "0.3.0" revision commit))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/wolever/pprintpp")
+                      (commit commit)))
+                (file-name (git-file-name name version))
+                (sha256
+                 (base32
+                  "0nk935m3ig8sc32laqbh698vwpk037yw27gd3nvwwzdv42jal2li"))))
+      (inputs (list python-pypa-build python-hypothesis python-wheel
+                    python-parameterized))
+      (native-inputs (list python-pytest python-nose))
+      (build-system python-build-system)
+      (arguments
+       (list #:phases #~(modify-phases %standard-phases
+                          (replace 'build
+                            (lambda _
+                              (setenv "SOURCE_DATE_EPOCH" "315532800")
+                              (invoke "python"
+                                      "-m"
+                                      "build"
+                                      "--wheel"
+                                      "--no-isolation"
+                                      ".")))
+                          (replace 'install
+                            (lambda* (#:key outputs #:allow-other-keys)
+                              (let ((whl (car (find-files "dist" "\\.whl$"))))
+                                (invoke "pip"
+                                        "--no-cache-dir"
+                                        "--no-input"
+                                        "install"
+                                        "--no-deps"
+                                        "--prefix"
+                                        #$output
+                                        whl))))
+                          (replace 'check
+                            (lambda* (#:key tests? #:allow-other-keys)
+                              (when tests?
+                                (invoke "python" "test.py")))))))
+      (home-page "https://github.com/wolever/pprintpp")
+      (synopsis "Python pretty-printer")
+      (description
+       "This package is a printer for Python which pretty-prints structures.
+It also attempts to print Unicode characters without escaping them.")
+      (license license:bsd-3))))
+
 (define-public python-kazoo
   (package
     (name "python-kazoo")

base-commit: fd6cd9de8682c7ddf96bf8deb637b1ca6cdbd205
-- 
2.37.3

[bug#58310] [PATCH 02/14] gnu: Add python-pluggy-1.0.* gnu/packages/python-xyz.scm (python-pluggy-1.0): New variable.

[Garek Dyszel via Guix-patches via]

* gnu/packages/python-xyz.scm (python-pluggy-1.0): New variable.
---
 gnu/packages/python-xyz.scm | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/gnu/packages/python-xyz.scm b/gnu/packages/python-xyz.scm
index 439765dc4f..8a4ac37abf 100644
--- a/gnu/packages/python-xyz.scm
+++ b/gnu/packages/python-xyz.scm
@@ -14741,6 +14741,20 @@ (define-public python-pluggy
    (home-page "https://pypi.org/project/pluggy/")
    (license license:expat)))
 
+(define-public python-pluggy-1.0
+  (package
+    (inherit python-pluggy)
+    (name "python-pluggy")
+    (version "1.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (pypi-uri "pluggy" version))
+              (sha256
+               (base32
+                "0n8iadlas2z1b4h0fc73b043c7iwfvx9rgvqm1azjmffmhxkf922"))))
+    (inputs (list python-pypa-build python-wheel))
+    (native-inputs (list python-pytest python-setuptools-scm))))
+
 (define-public python-plumbum
   (package
     (name "python-plumbum")
-- 
2.37.3

[bug#58310] [PATCH 03/14] gnu: Add python-setuptools-scm-7.* gnu/packages/python-build.scm (python-setuptools-scm-7): New variable.

[Garek Dyszel via Guix-patches via]

* gnu/packages/python-build.scm (python-setuptools-scm-7): New variable.
---
 gnu/packages/python-build.scm | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/gnu/packages/python-build.scm b/gnu/packages/python-build.scm
index 9d9b07f769..e17cde16d9 100644
--- a/gnu/packages/python-build.scm
+++ b/gnu/packages/python-build.scm
@@ -476,6 +476,25 @@ (define-public python-setuptools-scm
 them as the version argument or in a SCM managed file.")
     (license license:expat)))
 
+(define-public python-setuptools-scm-7
+  (package
+    (inherit python-setuptools-scm)
+    (version "7.0.5")
+    (source (origin
+              (method url-fetch)
+              (uri (pypi-uri "setuptools_scm" version))
+              (sha256
+               (base32
+                "0i28zghzdzzkm9w8rrjwphggkfs58nh6xnqsjhmqjvqxfypi67h3"))))
+    (build-system python-build-system)
+    (arguments
+     `( ;Disabled tests to avoid extra dependencies.
+       #:tests? #f
+       #:phases (modify-phases %standard-phases
+                  ;; Disabled sanity check to avoid extra dependencies.
+                  (delete 'sanity-check))))
+    (propagated-inputs (list python-packaging-bootstrap python-tomli))))
+
 (define-public python-editables
   (package
     (name "python-editables")
-- 
2.37.3

[bug#58310] [PATCH 04/14] gnu: Add python-hatchling-bootstrap.

[Garek Dyszel via Guix-patches via]

* gnu/packages/python-build.scm (python-hatchling-bootstrap): New variable.
---
 gnu/packages/python-build.scm | 63 +++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/gnu/packages/python-build.scm b/gnu/packages/python-build.scm
index e17cde16d9..f90d23874f 100644
--- a/gnu/packages/python-build.scm
+++ b/gnu/packages/python-build.scm
@@ -516,3 +516,66 @@ (define-public python-editables
 ``editable mode''.  In other words, changes to the package source will be
 reflected in the package visible to Python, without needing a reinstall.")
     (license license:expat)))
+
+;; This depends on packages in python-xyz.scm:
+;; python-version, python-importlib-metadata, python-pathspec,
+;; python-pluggy-1.0, and python-platformdirs.
+(define-public python-hatchling-bootstrap
+  (package
+    (name "python-hatchling-bootstrap")
+    (version "1.10.0")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/pypa/hatch")
+                    (commit (string-append "hatchling-v" version))))
+              (file-name (git-file-name name version))
+              (sha256
+               (base32
+                ;;"1q25kqw71g8mjwfjz9ph0iigdqa26zzxgmqm0v0bp0z1j8rcl237"
+                "1yqkwck2aihfdm9ljv5q4nygmmqyp35xwyp8lqn2f4vq9p6njq3c"))))
+    ;; python-pypa-build needed for bootstrapping.
+    ;; Otherwise we get a circular reference:
+    ;; python-hatchling trying to build itself, without
+    ;; first having hatchling installed.
+    (inputs (list python-pypa-build
+                  python-editables
+                  python-importlib-metadata
+                  python-version
+                  python-packaging-next
+                  python-pathspec
+                  python-pluggy-1.0 ;TODO: Not detected by pytest?
+                  python-tomli
+                  python-platformdirs))
+    (build-system python-build-system)
+    (arguments
+     `( ;Tests depend on module python-hatch, which this
+       ;; is bootstrapping.
+       #:tests? #f
+       #:phases (modify-phases %standard-phases
+                  (replace 'build
+                    (lambda _
+                      (chdir "backend")
+                      ;; ZIP does not support timestamps before 1980.
+                      (setenv "SOURCE_DATE_EPOCH" "315532800")
+                      (invoke "python"
+                              "-m"
+                              "build"
+                              "--wheel"
+                              "--no-isolation"
+                              ".")))
+                  (replace 'install
+                    (lambda* (#:key outputs #:allow-other-keys)
+                      (let ((whl (car (find-files "dist" "\\.whl$"))))
+                        (invoke "pip"
+                                "--no-cache-dir"
+                                "--no-input"
+                                "install"
+                                "--no-deps"
+                                "--prefix"
+                                (assoc-ref %outputs "out")
+                                whl)))))))
+    (home-page "https://ofek.dev/projects/hatch/")
+    (synopsis "Bootstrap binaries to build @code{python-hatch}")
+    (description "Bootstrap binaries to build @code{python-hatch}")
+    (license license:expat)))
-- 
2.37.3

[bug#58310] [PATCH 05/14] gnu: Add python-hatch.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/python-build.scm b/gnu/packages/python-build.scm
index f90d23874f..0b8d8a7647 100644
--- a/gnu/packages/python-build.scm
+++ b/gnu/packages/python-build.scm
@@ -579,3 +579,64 @@ (define-public python-hatchling-bootstrap
     (synopsis "Bootstrap binaries to build @code{python-hatch}")
     (description "Bootstrap binaries to build @code{python-hatch}")
     (license license:expat)))
+
+(define-public python-hatch
+  (package
+    (name "python-hatch")
+    (version "1.10.0")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/pypa/hatch")
+                    (commit (string-append "hatch-v" version))))
+              (file-name (git-file-name name version))
+              (sha256
+               (base32
+                "030yi9hw50mn899pq073lw2a55r57skl2g9agjp3b4l95f3nay30"))))
+    (inputs (list python-pypa-build
+                  python-editables
+                  python-importlib-metadata
+                  python-version
+                  python-packaging-next
+                  python-pathspec
+                  python-pluggy-1.0 ;TODO: Not detected by pytest?
+                  python-hatchling-bootstrap
+                  python-tomli
+                  python-platformdirs
+                  python-rich
+                  python-tomli-w))
+    (build-system python-build-system)
+    (arguments
+     `( ;Tests appear to be written such that the input python-pluggy-1.0 is
+       ;; not detected.
+       #:tests? #f
+       #:phases (modify-phases %standard-phases
+                  (replace 'build
+                    (lambda _
+                      ;; ZIP does not support timestamps before 1980.
+                      (setenv "SOURCE_DATE_EPOCH" "315532800")
+                      (invoke "hatchling" "build")))
+                  (replace 'install
+                    (lambda* (#:key outputs #:allow-other-keys)
+                      (let ((whl (car (find-files "dist" "\\.whl$"))))
+                        (invoke "pip"
+                                "--no-cache-dir"
+                                "--no-input"
+                                "install"
+                                "--no-deps"
+                                "--prefix"
+                                (assoc-ref %outputs "out")
+                                whl))))
+                  (replace 'check
+                    (lambda* (#:key tests? #:allow-other-keys)
+                      (when tests?
+                        (chdir "tests")
+                        (invoke "pytest" "-vv"))))
+                  ;; Can't have hatch as a requirement of itself.
+                  (delete 'sanity-check))))
+    (home-page "https://ofek.dev/projects/hatch/")
+    (synopsis "Python build system with project generation")
+    (description
+     "Python build system with project generation.  It also defines a specific
+syntax in @code{toml} files to check for dependencies.")
+    (license license:expat)))
-- 
2.37.3

[bug#58310] [PATCH 06/14] gnu: Add python-hatch-vcs.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/python-xyz.scm b/gnu/packages/python-xyz.scm
index 8a4ac37abf..5739c759de 100644
--- a/gnu/packages/python-xyz.scm
+++ b/gnu/packages/python-xyz.scm
@@ -27391,6 +27391,66 @@ (define-public python-versioneer
 process.")
     (license license:public-domain)))
 
+(define-public python-hatch-vcs
+  ;; Tags are not accurate; just use the commit itself.
+  (let ((commit "367daedb23ba906f3e0714c64392fdd6ffa69ab2")
+        (revision "1"))
+    (package
+      (name "python-hatch-vcs")
+      (version (git-version "0.2.0" revision commit))
+      (source (origin
+                (method git-fetch)
+                (uri (git-reference
+                      (url "https://github.com/ofek/hatch-vcs")
+                      (commit commit)))
+                (file-name (git-file-name name version))
+                (sha256
+                 (base32
+                  "0nlnv32jqiz8ikc013h5simmiqqg0qa7pm0qcbd8yiqq1p43iw05"))))
+      (build-system python-build-system)
+      (inputs (list python-pypa-build
+                    python-pathspec
+                    python-pluggy-1.0
+                    python-editables
+                    git
+                    python-hatchling-bootstrap
+                    python-typing-extensions))
+      (native-inputs (list python-pytest
+                           ;; python-setuptools-scm-6.4 minimum
+                           python-setuptools-scm-7))
+      (arguments
+       (list #:phases #~(modify-phases %standard-phases
+                          (replace 'build
+                            (lambda _
+                              (setenv "SOURCE_DATE_EPOCH" "315532800")
+                              (invoke "python"
+                                      "-m"
+                                      "build"
+                                      "--wheel"
+                                      "--no-isolation"
+                                      ".")))
+                          (replace 'install
+                            (lambda* (#:key outputs #:allow-other-keys)
+                              (let ((whl (car (find-files "dist" "\\.whl$"))))
+                                (invoke "pip"
+                                        "--no-cache-dir"
+                                        "--no-input"
+                                        "install"
+                                        "--no-deps"
+                                        "--prefix"
+                                        #$output
+                                        whl))))
+                          (replace 'check
+                            (lambda* (#:key tests? #:allow-other-keys)
+                              (when tests?
+                                (invoke "pytest" "-vvv"))))))) ;)
+      (home-page "https://ofek.dev/projects/hatch/")
+      (synopsis "Plugin for @code{python-hatch} to include versions")
+      (description
+       "This plugin defines a version-control syntax for use with
+@code{toml} files intended for use with @code{python-hatch}.")
+      (license license:expat))))
+
 (define-public python-gamera
   (package
     (name "python-gamera")
-- 
2.37.3

[bug#58310] [PATCH 07/14] gnu: Add python-pytest-icdiff.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/python-check.scm b/gnu/packages/python-check.scm
index 2358e7448d..6d0885d6dc 100644
--- a/gnu/packages/python-check.scm
+++ b/gnu/packages/python-check.scm
@@ -16,6 +16,7 @@
 ;;; Copyright © 2022 Malte Frank Gerdes <malte.f.gerdes@gmail.com>
 ;;; Copyright © 2022 Felix Gruber <felgru@posteo.net>
 ;;; Copyright © 2022 Tomasz Jeneralczyk <tj@schwi.pl>
+;;; Copyright © 2022 Garek Dyszel <garekdyszel@disroot.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -182,6 +183,26 @@ (define-public python-pytest-csv
 it adds to the Pytest command line interface (CLI).")
     (license license:gpl3+)))
 
+(define-public python-pytest-icdiff
+  (package
+    (name "python-pytest-icdiff")
+    (version "0.6")
+    (source (origin
+              (method url-fetch)
+              (uri (pypi-uri "pytest-icdiff" version))
+              (sha256
+               (base32
+                "1b8vzn2hvv6x25w1s446q1rfsbdik617lzpal3qb94x8a12yzwg8"))))
+    (build-system python-build-system)
+    (propagated-inputs (list python-pypa-build python-icdiff python-pprintpp))
+    (native-inputs (list python-pytest))
+    (home-page "https://github.com/hjwp/pytest-icdiff")
+    (synopsis "Colored diffs using @code{python-icdiff} for pytest output")
+    (description
+     "This package uses @code{python-icdiff} to add color to the output of
+pytest assertions.")
+    (license (license:non-copyleft "LICENSE"))))
+
 (define-public python-testfixtures
   (package
     (name "python-testfixtures")
-- 
2.37.3

[bug#58310] [PATCH 08/14] gnu: Add python-hatch-fancy-pypi-readme.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/python-xyz.scm b/gnu/packages/python-xyz.scm
index 5739c759de..8ee2da0a07 100644
--- a/gnu/packages/python-xyz.scm
+++ b/gnu/packages/python-xyz.scm
@@ -30074,6 +30074,74 @@ (define-public python-style
 a port of the chalk package for javascript.")
     (license license:expat)))
 
+(define-public python-hatch-fancy-pypi-readme
+  (package
+    (name "python-hatch-fancy-pypi-readme")
+    (version "22.8.0")
+    (source (origin
+              (method url-fetch)
+              (uri (pypi-uri "hatch_fancy_pypi_readme" version))
+              (sha256
+               (base32
+                "1ykfz1sbz58xbjw5k9xpmn5r6ji16w8vag47j8f969bqy3w52ikx"))))
+    (build-system python-build-system)
+    (propagated-inputs (list python-tomli python-typing-extensions))
+    (native-inputs (list python-pypa-build
+                         python-pathspec
+                         python-pluggy-1.0
+                         python-editables
+                         python-hatch
+                         python-hatchling-bootstrap
+                         python-wheel
+                         python-pytest
+                         python-pytest-icdiff))
+    (arguments
+     `(#:phases (modify-phases %standard-phases
+                  (add-before 'build 'disable-broken-tests
+                    (lambda _
+                      ;; Skip the tests for "building". Guix already does this,
+                      ;; so we don't need to test it for this package.
+                      (chdir "tests")
+                      (invoke "sed" "-i"
+                              "11ipytest.skip('No need to test\
+ building; guix does this already', allow_module_level=True)"
+                              "test_end_to_end.py")
+                      (chdir "../")))
+                  ;; XXX: PEP 517 manual build/install procedures copied from
+                  ;; python-isort.
+                  (replace 'build
+                    (lambda _
+                      ;; ZIP does not support timestamps before 1980.
+                      (setenv "SOURCE_DATE_EPOCH" "315532800")
+                      (invoke "python"
+                              "-m"
+                              "build"
+                              "--wheel"
+                              "--no-isolation"
+                              ".")))
+                  (replace 'install
+                    (lambda* (#:key outputs #:allow-other-keys)
+                      (let ((whl (car (find-files "dist" "\\.whl$"))))
+                        (invoke "pip"
+                                "--no-cache-dir"
+                                "--no-input"
+                                "install"
+                                "--no-deps"
+                                "--prefix"
+                                (assoc-ref %outputs "out")
+                                whl))))
+                  (replace 'check
+                    (lambda* (#:key tests? #:allow-other-keys)
+                      (when tests?
+                        (invoke "pytest" "-vv")))))))
+    (home-page
+     "https://github.com/hynek/hatch-fancy-pypi-readme")
+    (synopsis "Syntax for styling PyPI READMEs")
+    (description
+     "Defines a syntax for the python-hatch build system, intended for styling
+READMEs for PyPI.")
+    (license license:expat)))
+
 (define-public python-sre-yield
   (package
     (name "python-sre-yield")
-- 
2.37.3

[bug#58310] [PATCH 09/14] gnu: python-jsonschema-next: Update to 4.16.0.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/python-xyz.scm b/gnu/packages/python-xyz.scm
index 8ee2da0a07..e1da4386e2 100644
--- a/gnu/packages/python-xyz.scm
+++ b/gnu/packages/python-xyz.scm
@@ -3631,13 +3631,13 @@ (define-public python-jsonschema
 (define-public python-jsonschema-next
   (package
     (inherit python-jsonschema)
-    (version "4.5.1")
+    (version "4.16.0")
     (source
      (origin
        (method url-fetch)
        (uri (pypi-uri "jsonschema" version))
        (sha256
-        (base32 "1z0x22691jva7lwfcfh377jdmlz68zhiawxzl53k631l34k8hvbw"))))
+        (base32 "07pyh8g4csapkfjgjww7vkxwvh1qwxwqxz82wm2b1kmxj69rgx11"))))
     (arguments
      (substitute-keyword-arguments (package-arguments python-jsonschema)
        ((#:phases phases)
@@ -3655,13 +3655,23 @@ (define-public python-jsonschema-next
                   (invoke "pip" "--no-cache-dir" "--no-input"
                           "install" "--no-deps" "--prefix" #$output whl))))))))
     (native-inputs (list python-pypa-build
-                         python-setuptools-scm
-                         python-twisted))
+                         python-twisted
+                         python-hatch
+                         python-hatchling-bootstrap
+                         python-pathspec
+                         python-pluggy-1.0
+                         python-editables
+                         python-hatch-vcs
+                         python-setuptools-scm-7
+                         python-hatch-fancy-pypi-readme))
     (propagated-inputs
      (list python-attrs
            python-importlib-metadata
            python-pyrsistent
-           python-typing-extensions))))
+           python-typing-extensions
+           python-hatch-vcs))
+    (home-page
+     "https://github.com/python-jsonschema/jsonschema")))
 
 (define-public python-schema
   (package
-- 
2.37.3

[bug#58310] [PATCH 10/14] gnu: Add ocaml-atd.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/ocaml.scm b/gnu/packages/ocaml.scm
index 4bc159481e..bc876d60a1 100644
--- a/gnu/packages/ocaml.scm
+++ b/gnu/packages/ocaml.scm
@@ -4955,6 +4955,58 @@ (define-public ocaml-earley
 is also support for writing OCaml syntax extensions in a camlp4 style.")
     (license license:cecill-b)))
 
+(define-public ocaml-atd
+  (package
+    (name "ocaml-atd")
+    (version "2.10.0")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/ahrefs/atd")
+                    (commit version)))
+              (file-name (git-file-name name version))
+              (sha256
+               (base32
+                "10fgahdigrl01py0k0q2d6a60yps38q96dxhjnzm9jz4g931716l"))))
+    (build-system dune-build-system)
+    (arguments
+     `(#:phases (modify-phases %standard-phases
+                  (replace 'check
+                    (lambda* (#:key tests? #:allow-other-keys)
+                      ;; The dune-build-system does not run "make test" but
+                      ;; "dune runtest test --release".
+                      ;; This project, rather, needs us to run "make test".
+                      ;;
+                      ;; For this package (ocaml-atd), we DO NOT run all the
+                      ;; tests. The atd repository has resources for several
+                      ;; different interfaces (python, scala, etc), but we
+                      ;; don't need to run those tests if we are just
+                      ;; interested in the ocaml interface.
+                      ;; So we stick with just the ocaml tests here.
+                      (when tests?
+                        (invoke "make" "test-ocaml")))))))
+    (propagated-inputs (list ocaml-menhir
+                             ocaml-easy-format
+                             ocaml-odoc
+                             ocaml-re
+                             ocaml-camlp-streams
+                             ocaml-biniou
+                             ocaml-yojson
+                             ocaml-cmdliner))
+    (native-inputs (list ocaml-alcotest
+                         python-pypa-build
+                         python-jsonschema-4.15
+                         python-flake8
+                         python-mypy
+                         python-pytest))
+    (inputs (list python))
+    (home-page "https://github.com/ahrefs/atd")
+    (synopsis "Parser for the ATD data format description language")
+    (description
+     "ATD is an OCaml library providing a parser for the Adjustable Type
+Definitions language.")
+    (license (license:non-copyleft "LICENSE.md"))))
+
 (define-public ocaml-timed
   (package
     (name "ocaml-timed")
-- 
2.37.3

[bug#58310] [PATCH 11/14] gnu: Add ocaml-elpi.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/ocaml.scm b/gnu/packages/ocaml.scm
index bc876d60a1..641a139e51 100644
--- a/gnu/packages/ocaml.scm
+++ b/gnu/packages/ocaml.scm
@@ -5007,6 +5007,54 @@ (define-public ocaml-atd
 Definitions language.")
     (license (license:non-copyleft "LICENSE.md"))))
 
+(define-public ocaml-elpi
+  (package
+    (name "ocaml-elpi")
+    ;; For more information on which version works with Coq 8.16,
+    ;; see the relevant issue:
+    ;; https://github.com/math-comp/hierarchy-builder/issues/297
+    ;; Here we use
+    ;; coq-elpi 1.15.4 + ocaml-elpi 1.16.5 +
+    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.16).
+    ;; (version "1.15.2")
+    (version "1.16.5")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/LPCIC/elpi")
+                    (commit (string-append "v" version))))
+              (file-name (git-file-name name version))
+              (sha256
+               (base32
+                ;; "0swzqabwrxqb6sz8zpild2lfcnk3l0zxi9fw61dy2g1pzws2j2jy")
+                "1l6grpglkvyyj0p01l0q5ih12lp4vizamgj7i63ig82gqpyzk9dl"))))
+    (build-system dune-build-system)
+    (arguments
+     `(#:test-target "tests"))
+    ;; Build currently fails with error (repeated several times):
+    ;; 'Warning 6 [labels-omitted: label argsdepth was omitted in the
+    ;; application of this function.'
+    (propagated-inputs (list ocaml-stdlib-shims
+                             ocaml-ppxlib
+                             ocaml-menhir
+                             ocaml-re
+                             ocaml-ppx-deriving
+                             ocaml-atd
+                             ocaml-camlp-streams
+                             ocaml-biniou
+                             ocaml-yojson))
+    (native-inputs (list ocaml-ansiterminal ocaml-cmdliner time))
+    (home-page "https://github.com/LPCIC/elpi")
+    (synopsis "ELPI - Embeddable λProlog Interpreter")
+    (description
+     "ELPI is an extension language for OCaml.  It implements a variant of
+λProlog enriched with Constraint Handling Rules, a programming language for
+manipulating syntax trees with binders.
+
+This package provides both a command line interpreter, elpi, and an OCaml
+library with the same name.")
+    (license license:lgpl2.1+)))
+
 (define-public ocaml-timed
   (package
     (name "ocaml-timed")
-- 
2.37.3

[bug#58310] [PATCH 12/14] gnu: Add coq-elpi.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/coq.scm b/gnu/packages/coq.scm
index 60937af750..313366cb11 100644
--- a/gnu/packages/coq.scm
+++ b/gnu/packages/coq.scm
@@ -771,3 +771,75 @@ (define-public coq-mathcomp-bigenough
 purposes as @code{bigenough} will be subsumed by the near tactics.  The
 formalization is based on the Mathematical Components library.")
     (license license:cecill-b)))
+
+(define-public coq-elpi
+  (package
+    (name "coq-elpi")
+    ;; For more information on which version works with Coq 8.16,
+    ;; see the relevant issue:
+    ;; https://github.com/math-comp/hierarchy-builder/issues/297
+    ;; Here we use
+    ;; coq-elpi 1.15.4 + ocaml-elpi 1.16.5 +
+    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.16)
+    (version "1.15.4")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/LPCIC/coq-elpi")
+                    (commit (string-append "v" version))))
+              (file-name (git-file-name name version))
+              (sha256
+               (base32
+                "115ll1g5dyn8z58x7xg6nsliga669875s560j5053flr6cvb8mq1"))))
+    (build-system gnu-build-system)
+    (arguments
+     `(#:make-flags ,#~(list (string-append "COQBIN="
+                                            #$(this-package-input "coq-core")
+                                            "/bin/")
+                             (string-append "ELPIDIR="
+                                            #$(this-package-input "ocaml-elpi")
+                                            "/lib/ocaml/site-lib/elpi")
+                             (string-append "COQMF_COQLIB="
+                                            (assoc-ref %outputs "out")
+                                            "/lib/ocaml/site-lib/coq")
+                             (string-append "COQLIBINSTALL="
+                                            (assoc-ref %outputs "out")
+                                            "/lib/coq/user-contrib"))
+
+       #:phases (modify-phases %standard-phases
+                  (delete 'configure)
+                  ;; --- old phase from version 1.14.0
+                  (add-before 'build 'remove-extra-src-file
+                    (lambda* (#:key outputs #:allow-other-keys)
+                      ;; Remove the useless line "src/META.coq-elpi"
+                      ;; in file _CoqProject. The file
+                      ;; src/META.coq-elpi does not exist in the
+                      ;; repository, so this line inhibits compilation
+                      ;; unnecessarily.
+                      (invoke "sed" "-i" "s|src/META.coq-elpi||g"
+                              "_CoqProject")))
+                  (replace 'check
+                    ;; Error when running the "check" phase:
+                    ;; "make: *** No rule to make target 'check'.
+                    ;; Stop."
+                    ;; Tests run if we invoke "make test" instead.
+                    (lambda* (#:key tests? make-flags #:allow-other-keys)
+                      (when tests?
+                        (apply invoke "make" "test" make-flags)))))))
+    (propagated-inputs (list ocaml
+                             ocaml-stdlib-shims
+                             ocaml-elpi
+                             ocaml-zarith
+                             coq-core
+                             coq-stdlib))
+    (inputs (list python))
+    (home-page "https://github.com/LPCIC/coq-elpi")
+    (synopsis "Elpi extension language for Coq")
+    (description
+     "Coq-elpi provides a Coq plugin that embeds ELPI, an extension language
+for OCaml that is an implementation of λProlog.  It also provides a way to
+embed Coq's terms into λProlog using the Higher-Order Abstract Syntax approach
+and a way to read terms back.  In addition to that it exports to ELPI a set of
+Coq's primitives.  Finally it provides a way to define new vernacular commands
+and new tactics.")
+    (license license:lgpl2.1)))
-- 
2.37.3

[bug#58310] [PATCH 13/14] gnu: Add coq-mathcomp-hierarchy-builder.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/coq.scm b/gnu/packages/coq.scm
index 313366cb11..184e503dd5 100644
--- a/gnu/packages/coq.scm
+++ b/gnu/packages/coq.scm
@@ -843,3 +843,65 @@ (define-public coq-elpi
 Coq's primitives.  Finally it provides a way to define new vernacular commands
 and new tactics.")
     (license license:lgpl2.1)))
+
+(define-public coq-mathcomp-hierarchy-builder
+  (package
+    (name "coq-mathcomp-hierarchy-builder")
+    ;; For more information on which version works with Coq 8.16,
+    ;; see the relevant issue:
+    ;; https://github.com/math-comp/hierarchy-builder/issues/297
+    ;; Here we use
+    ;; coq-elpi 1.15.4 + ocaml-elpi 1.16.5 +
+    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.16)
+    (version "1.3.0")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/math-comp/hierarchy-builder")
+                    (commit (string-append "v" version))))
+              (file-name (git-file-name name version))
+              (sha256
+               (base32
+                "17k7rlxdx43qda6i1yafpgc64na8br285cb0mbxy5wryafcdrkrc"))))
+    (build-system gnu-build-system)
+    (arguments
+     `(#:test-target "test-suite"
+       #:make-flags ,#~(list (string-append "COQBIN="
+                                            #$(this-package-input "coq-core")
+                                            "/bin/")
+                             (string-append "COQBININSTALL="
+                                            (assoc-ref %outputs "out") "/bin/")
+                             (string-append "DESTDIR="
+                                            (assoc-ref %outputs "out"))
+                             (string-append "ELPIDIR="
+                                            #$(this-package-input "ocaml-elpi")
+                                            "/lib/ocaml/site-lib/elpi")
+                             (string-append "COQMF_COQLIB="
+                                            (assoc-ref %outputs "out")
+                                            "/lib/ocaml/site-lib/coq")
+                             (string-append "COQLIBINSTALL="
+                                            (assoc-ref %outputs "out")
+                                            "/lib/coq/user-contrib"))
+       #:phases (modify-phases %standard-phases
+                  (delete 'configure)
+                  (replace 'build
+                    (lambda* (#:key make-flags #:allow-other-keys)
+                      (apply invoke "make" "build" make-flags))))))
+    (inputs (list coq
+                  coq-core
+                  coq-mathcomp
+                  which
+                  ocaml
+                  coq-elpi
+                  ocaml-elpi))
+    (synopsis "Hierarchy structures for the Coq proof assistant")
+    (description
+     "Hierarchy Builder (HB) provides high level commands to declare a
+hierarchy of interfaces for the Coq system.
+
+Given a structure one can develop its theory, and that theory becomes
+applicable to all examples of the structure.  One can also declare alternative
+interfaces, for convenience or backward compatibility, and provide glue code
+linking these interfaces to the structures part of the hierarchy.")
+    (home-page "https://math-comp.github.io/")
+    (license license:expat)))
-- 
2.37.3

[bug#58310] [PATCH 14/14] gnu: Add coq-mathcomp-analysis.

[Garek Dyszel via Guix-patches via]

diff --git a/gnu/packages/coq.scm b/gnu/packages/coq.scm
index 184e503dd5..f7b4c504f9 100644
--- a/gnu/packages/coq.scm
+++ b/gnu/packages/coq.scm
@@ -905,3 +905,67 @@ (define-public coq-mathcomp-hierarchy-builder
 linking these interfaces to the structures part of the hierarchy.")
     (home-page "https://math-comp.github.io/")
     (license license:expat)))
+
+(define-public coq-mathcomp-analysis
+  (package
+    (name "coq-mathcomp-analysis")
+    (version "0.5.4")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://github.com/math-comp/analysis")
+                    (commit version)))
+              (file-name (git-file-name name version))
+              (sha256
+               (base32
+                "1l1yaxbmqr4li8x7g51q98a6v383dnf94lw1b74ccpwqz9qybz9m"))))
+    (build-system gnu-build-system)
+    (arguments
+     `( ;No rule to make target 'check'. Stop.
+       ;; Makefile.common has no references to tests.
+       ;; There are also no references to tests found after
+       ;; running the following commands in the top
+       ;; directory of the cloned repo:
+       ;; find -type d | grep -i test
+       ;; rg test # where rg is ripgrep
+       ;; Checking the git log, we find: "Add test suite for
+       ;; joins and several fixes".
+       ;;
+       ;; If tests are included, this quote suggests that they
+       ;; would be part of the source files themselves,
+       ;; and the tests would be run as part of the build
+       ;; process.
+       #:tests? #f
+       #:make-flags ,#~(list (string-append "COQBIN="
+                                            #$(this-package-input "coq-core")
+                                            "/bin/")
+                             (string-append "COQBININSTALL="
+                                            (assoc-ref %outputs "out") "/bin/")
+                             (string-append "DESTDIR="
+                                            (assoc-ref %outputs "out"))
+                             (string-append "COQMF_COQLIB="
+                                            (assoc-ref %outputs "out")
+                                            "/lib/ocaml/site-lib/coq")
+                             (string-append "COQLIBINSTALL="
+                                            (assoc-ref %outputs "out")
+                                            "/lib/coq/user-contrib"))
+       #:phases (modify-phases %standard-phases
+                  (delete 'configure)
+                  (replace 'build
+                    (lambda* (#:key make-flags #:allow-other-keys)
+                      (apply invoke "make" "build" make-flags))))))
+    (inputs (list coq
+                  coq-stdlib
+                  coq-mathcomp
+                  coq-mathcomp-finmap
+                  coq-mathcomp-hierarchy-builder
+                  coq-elpi
+                  coq-mathcomp-bigenough
+                  coq-core
+                  which))
+    (synopsis "Real analysis for the Coq proof assistant")
+    (description
+     "This repository contains an experimental library for real analysis for
+the Coq proof-assistant, using the Mathematical Components library.")
+    (home-page "https://math-comp.github.io/")
+    (license license:cecill-c)))
-- 
2.37.3

[bug#58310] Temporary manifest for coq-mathcomp-analysis

[Garek Dyszel via Guix-patches via]

Since the above patch set does not correctly build with Coq 8.16,
here are a manifest file, a channels file, and a package file to get us
through. These files rely on Coq 8.15.2.

I didn't try to clean these files up or anything. They do work for me,
though, until we can figure out how to build coq-mathcomp-analysis for
Coq 8.16. I tested it with Emacs Proof General.

If all files are in the same folder, they can be used by running the
following. (Note also: to get a valid channel for the channels.scm file,
we have to create a dummy git repository.)

$ mkdir mathcomp-extra-packages && cp coq-mathcomp-analysis.scm ./test
$ cd test
$ git init
$ git add coq-mathcomp-analysis.scm
$ git commit "random commit name"
$ cd ../
$ guix time-machine -C ./channels.scm\
  -- shell -m guix-manifest.scm -- emacs ./

(One can omit "-- emacs ./" if they just want the packages available,
but want to use a different editor.)

A final note is that if Emacs does not detect the presence of
coq-mathcomp-analysis, it could befixed with the following local
variables.
#+begin_src coq
  (* Local Variables: *)
  (* mode: coq *)
  (* eval: (setq coq-prog-name "coqtop") *)
  (* eval: (setq coq-compiler "coqc") *)
  (* eval: (setq coq-dependency-analyzer "coqdep") *)
  (* End: *)
#+end_src

coq-mathcomp-analysis.scm
--8<---------------cut here---------------start------------->8---
;;; This module extends GNU Guix and is licensed under the same terms, those
;;; of the GNU GPL version 3 or (at your option) any later version.
;;;
;;; Copyright © 2022 Garek Dyszel <garekdyszel@disroot.org>

(define-module (coq-mathcomp-analysis)
  #:use-module (guix)
  #:use-module (guix git-download)
  #:use-module (guix download)
  #:use-module (guix packages)
  #:use-module (guix build-system gnu)
  #:use-module (guix build gnu-build-system)
  #:use-module (guix build-system dune)
  #:use-module (guix build-system ocaml)
  ;; #:use-module ((guix build utils) #:prefix utils:)
  #:use-module ((guix licenses)
                #:prefix license:)
  #:use-module ((gnu packages base)
                #:prefix base:)
  #:use-module (guix build utils)
  #:use-module (guix utils)
  #:use-module (guix profiles)
  #:use-module (gnu packages coq)
  #:use-module (gnu packages base)
  #:use-module (gnu packages ocaml)
  #:use-module (gnu packages time)
  #:use-module (gnu packages python)
  #:use-module (gnu packages python-xyz)
  #:use-module (gnu packages python-build)
  #:use-module (gnu packages python-web)
  #:use-module (gnu packages python-crypto)
  #:use-module (gnu packages xdisorg)
  #:use-module (guix build-system python)
  #:use-module (gnu packages python-check)
  #:use-module (gnu packages check)
  #:use-module (gnu packages java)
  #:use-module (gnu packages python-compression)
  #:use-module (gnu packages version-control))

;; This manifest builds coq-mathcomp-analysis for Coq 8.15.2.

;;; OCaml
(define-public ocaml-elpi
  (package
    (name "ocaml-elpi")
    ;; For more information on which version works with Coq 8.15,
    ;; see the relevant issue:
    ;; https://github.com/math-comp/hierarchy-builder/issues/297
    ;; Here we use
    ;; coq-elpi 1.14.0 + ocaml-elpi 1.15.2 +
    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.15)
    ;;
    ;; The package ocaml-elpi@1.16.5 appears to require a different
    ;; build process.
    (version "1.15.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/LPCIC/elpi")
                    (commit (string-append "v" version))
                    (recursive? #t)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0swzqabwrxqb6sz8zpild2lfcnk3l0zxi9fw61dy2g1pzws2j2jy"))))
    (build-system dune-build-system)
    (arguments
     `(#:test-target "tests"))
    (propagated-inputs (list ocaml-stdlib-shims
                             ocaml-ppxlib
                             ocaml-menhir
                             ocaml-re
                             ocaml-ppx-deriving
                             ocaml-atd
                             ocaml-camlp-streams
                             ocaml-biniou
                             ocaml-yojson))
    (native-inputs (list ocaml-ansiterminal ocaml-cmdliner time))
    (home-page "https://github.com/LPCIC/elpi")
    (synopsis "ELPI - Embeddable λProlog Interpreter")
    (description
     "ELPI implements a variant of λProlog enriched with Constraint
Handling Rules, a programming language well suited to manipulate
syntax trees with binders.

ELPI is designed to be embedded into larger applications written in
OCaml as an extension language.  It comes with an API to drive the
interpreter and with an FFI for defining built-in predicates and data
types, as well as quotations and similar goodies that are handy to
adapt the language to the host application.

This package provides both a command line interpreter (elpi) and a
library to be linked in other applications (eg by passing -package
elpi to ocamlfind).

The ELPI programming language has the following features:

@itemize
@item Native support for variable binding and substitution, via an Higher
Order Abstract Syntax (HOAS) embedding of the object language.  The
programmer does not need to care about technical devices to handle
bound variables, like De Bruijn indices.

@item Native support for hypothetical context.  When moving under a binder
one can attach to the bound variable extra information that is
collected when the variable gets out of scope.  For example when
writing a type-checker the programmer needs not to care about managing
the typing context.

@item Native support for higher order unification variables, again via
HOAS.  Unification variables of the meta-language (λProlog) can be
reused to represent the unification variables of the object language.
The programmer does not need to care about the unification-variable
assignment map and cannot assign to a unification variable a term
containing variables out of scope, or build a circular assignment.

@item Native support for syntactic constraints and their meta-level
handling rules.  The generative semantics of Prolog can be disabled by
turning a goal into a syntactic constraint (suspended goal).  A
syntactic constraint is resumed as soon as relevant variables gets
assigned.  Syntactic constraints can be manipulated by constraint
handling rules (CHR).

@item Native support for backtracking.  To ease implementation of search.

@item The constraint store is extensible.  The host application can declare
non-syntactic constraints and use custom constraint solvers to check
their consistency.

@item Clauses are graftable.  The user is free to extend an existing
program by inserting/removing clauses, both at runtime (using
implication) and at \"compilation\" time by accumulating files.
@end itemize

ELPI is free software released under the terms of LGPL 2.1 or above.")
    (license license:lgpl2.1)))

;; Requires python-jsonschema version 4.6.0 to run tests.
;; See https://github.com/ahrefs/atd/issues/306
(define-public ocaml-atd
  (package
    (name "ocaml-atd")
    (version "2.10.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/ahrefs/atd")
                    (commit version)
                    (recursive? #t)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "10fgahdigrl01py0k0q2d6a60yps38q96dxhjnzm9jz4g931716l"))))
    (build-system dune-build-system)
    (arguments
     `(;; The dependency python-jsonschema needs to be at
       ;; v4.6 in order for the python tests to pass.
       ;; See https://github.com/ahrefs/atd/issues/306 for more info
       ;; on that.
       ;;#:tests? #f
       #:phases (modify-phases %standard-phases
                  (replace 'check
                    (lambda* (#:key tests? #:allow-other-keys)
                      ;; The dune-build-system does not run "make test" but
                      ;; "dune runtest test --release".
                      ;; This project, rather, needs us to run "make test".
                      ;;
                      ;; For this package (ocaml-atd), we DO NOT run all the
                      ;; tests. The atd repository has resources for several
                      ;; different interfaces (python, scala, etc), but we
                      ;; don't need to run those tests for the ocaml package.
                      ;; So we stick with just the ocaml
                      ;; tests here.
                      (when tests?
                        (invoke "make" "test-ocaml")))))))
    (propagated-inputs (list ocaml-menhir
                             ocaml-easy-format
                             ocaml-odoc
                             ocaml-re
                             ocaml-camlp-streams
                             ocaml-biniou
                             ocaml-yojson
                             ocaml-cmdliner))
    (native-inputs (list ocaml-alcotest
                         python
                         python-pypa-build
                         python-jsonschema-4.15
                         python-flake8
                         python-mypy
                         python-pytest))
    (home-page "https://github.com/ahrefs/atd")
    (synopsis "Parser for the ATD data format description language")
    (description
     "ATD is the OCaml library providing a parser for the ATD language
and various utilities.  ATD stands for Adjustable Type Definitions in
reference to its main property of supporting annotations that allow a
good fit with a variety of data formats.")
    ;; Modified BSD license
    (license (license:non-copyleft "LICENSE.md"))))

(define-public ocaml-ansiterminal
  (package
    (name "ocaml-ansiterminal")
    (version "0.8.5")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/Chris00/ANSITerminal")
                    (commit version)
                    (recursive? #t)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "052qnc23vmxp90yympjz9q6lhqw98gs1yvb3r15kcbi1j678l51h"))))
    (build-system dune-build-system)
    (arguments
     `(#:test-target "tests"))
    (home-page "https://github.com/Chris00/ANSITerminal")
    (synopsis
     "Basic control of ANSI compliant terminals and the windows shell")
    (description
     "ANSITerminal is a module allowing to use the colors and cursor
movements on ANSI terminals.")
    ;; Variant of the GPL3 which permits
    ;; static and dynamic linking when producing binary files.
    ;; In other words, it allows one to link to the library
    ;; when compiling nonfree software.
    (license (license:non-copyleft "LICENSE"))))

;;; Coq
(define-public coq-elpi
  (package
    (name "coq-elpi")
    ;; For more information on which version works with Coq 8.15,
    ;; see the relevant issue:
    ;; https://github.com/math-comp/hierarchy-builder/issues/297
    ;; Here we use
    ;; coq-elpi 1.14.0 + ocaml-elpi 1.15.2 +
    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.15)
    (version "1.14.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/LPCIC/coq-elpi")
                    (commit (string-append "v" version))
                    (recursive? #t)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1v2p5dlpviwzky2i14cj7gcgf8cr0j54bdm9fl5iz1ckx60j6nvp"))))
    (build-system gnu-build-system)
    (arguments
     `(#:make-flags ,#~(list (string-append "COQBIN="
                                            #$(this-package-input "coq-core")
                                            "/bin/")
                             (string-append "ELPIDIR="
                                            #$(this-package-input "ocaml-elpi")
                                            "/lib/ocaml/site-lib/elpi")
                             (string-append "COQMF_COQLIB="
                                            (assoc-ref %outputs "out")
                                            "/lib/ocaml/site-lib/coq")
                             (string-append "COQLIBINSTALL="
                                            (assoc-ref %outputs "out")
                                            "/lib/coq/user-contrib"))

       #:phases (modify-phases %standard-phases
                  (delete 'configure)
                  (add-before 'build 'remove-extra-src-file
                    (lambda* (#:key outputs #:allow-other-keys)
                      ;; Remove the useless line
                      ;; "src/META.coq-elpi"
                      ;; in file _CoqProject.
                      ;; The file src/META.coq-elpi does not exist in
                      ;; the repository,
                      ;; so this line inhibits compilation unnecessarily.
                      (invoke "sed" "-i" "s|src/META.coq-elpi||g"
                              "_CoqProject")))
                  (replace 'check
                    ;; Error when running the "check" phase:
                    ;; "make: *** No rule to make target 'check'.  Stop."
                    (lambda* (#:key tests? make-flags #:allow-other-keys)
                      (when tests?
                        (apply invoke "make" "test" make-flags)))))))
    (inputs (list python))
    (propagated-inputs (list ocaml
                             ocaml-stdlib-shims
                             ocaml-elpi
                             ocaml-zarith
                             coq-core
                             coq-stdlib))
    (home-page "https://github.com/LPCIC/coq-elpi")
    (synopsis "Elpi extension language for Coq")
    (description
     "Coq-elpi provides a Coq plugin that embeds ELPI. It also
provides a way to embed Coq's terms into λProlog using the
Higher-Order Abstract Syntax approach and a way to read terms back. In
addition to that it exports to ELPI a set of Coq's primitives, e.g.
printing a message, accessing the environment of theorems and data
types, defining a new constant and so on. For convenience it also
provides a quotation and anti-quotation for Coq's syntax in λProlog.
E.g. @code{{{nat}}} is expanded to the type name of natural numbers,
or @code{{{A -> B}}} to the representation of a product by unfolding
the @code{->} notation. Finally it provides a way to define new
vernacular commands and new tactics.")
    (license license:lgpl2.1)))

(define-public coq-mathcomp-hierarchy-builder
  (package
    (name "coq-mathcomp-hierarchy-builder")
    ;; For more information on which version works with Coq 8.15,
    ;; see the relevant issue:
    ;; https://github.com/math-comp/hierarchy-builder/issues/297
    ;; Here we use
    ;; coq-elpi 1.14.0 + ocaml-elpi 1.15.2 +
    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.15)
    (version "1.3.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/math-comp/hierarchy-builder")
                    (commit (string-append "v" version))
                    (recursive? #t)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "17k7rlxdx43qda6i1yafpgc64na8br285cb0mbxy5wryafcdrkrc"))))
    (build-system gnu-build-system)
    (arguments
     `(#:test-target "test-suite"
       #:make-flags ,#~(list (string-append "COQBIN="
                                            #$(this-package-input "coq-core")
                                            "/bin/")
                             (string-append "COQBININSTALL="
                                            (assoc-ref %outputs "out") "/bin/")
                             (string-append "DESTDIR="
                                            (assoc-ref %outputs "out"))
                             (string-append "ELPIDIR="
                                            #$(this-package-input "ocaml-elpi")
                                            "/lib/ocaml/site-lib/elpi")
                             (string-append "COQMF_COQLIB="
                                            (assoc-ref %outputs "out")
                                            "/lib/ocaml/site-lib/coq")
                             (string-append "COQLIBINSTALL="
                                            (assoc-ref %outputs "out")
                                            "/lib/coq/user-contrib"))
       #:phases (modify-phases %standard-phases
                  (delete 'configure)
                  (replace 'build
                    (lambda* (#:key make-flags #:allow-other-keys)
                      (apply invoke "make" "build" make-flags)))
                  ;; (replace 'check
                  ;; (lambda* (#:key tests? make-flags #:allow-other-keys)
                  ;; (when tests?
                  ;; (apply invoke "make" "test-suite" make-flags))))
                  )))
    (inputs (list coq
                  coq-core
                  coq-mathcomp
                  which
                  ocaml
                  coq-elpi
                  ocaml-elpi))
    (synopsis "Hierarchy structures for the Coq proof assistant")
    (description
     "Hierarchy Builder (HB) provides high level commands to declare a
hierarchy of algebraic structure (or interfaces if you prefer the
glossary of computer science) for the Coq system.

Given a structure one can develop its theory, and that theory becomes
automatically applicable to all the examples of the structure.  One can
also declare alternative interfaces, for convenience or backward
compatibility, and provide glue code linking these interfaces to the
structures part of the hierarchy.

HB commands compile down to Coq modules, sections, records, coercions,
canonical structure instances and notations following the packed
classes discipline which is at the core of the Mathematical Components
library.  All that complexity is hidden behind a few concepts and a few
declarative Coq commands.")
    (home-page "https://math-comp.github.io/")
    ;; MIT license
    (license license:expat)))

(define-public coq-mathcomp-finmap
  (package
    (name "coq-mathcomp-finmap")
    (version "1.5.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/math-comp/finmap")
                    (commit version)
                    (recursive? #t)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1k72wpp15xa5ag358jl8a71gschng0bgbaqjx0l5a0in6x5adafh"))))
    (build-system gnu-build-system)
    (arguments
     `( ;"No rule to make target 'check'."
       ;; No tests supplied in Makefile.common.
       ;; The project doesn't appear to have plans to include tests in
       ;; the future.
       #:tests? #f
       #:make-flags (list (string-append "COQLIBINSTALL="
                                         (assoc-ref %outputs "out")
                                         "/lib/coq/user-contrib"))
       #:phases (modify-phases %standard-phases
                  (delete 'configure))))
    (inputs (list coq coq-stdlib coq-mathcomp which))
    (synopsis "Finite sets and finite types for coq-mathcomp")
    (description
     "This library is an extension of coq-mathcomp which supports finite sets
and finite maps on choicetypes (rather than finite types).  This includes
support for functions with finite support and multisets.  The library also
contains a generic order and set libary, which will eventually be used to
subsume notations for finite sets.")
    (home-page "https://math-comp.github.io/")
    (license license:cecill-b)))

(define-public coq-mathcomp-bigenough
  ;; On the homepage, it is mentioned that coq-mathcomp-bigenough
  ;; is going to be obsolete sometime in the near future.
  ;; This package was included because of the following error,
  ;; encountered while building coq-mathcomp-analysis:
  ;; "Warning: in file theories/altreals/realseq.v, library
  ;; mathcomp.bigenough.bigenough is required and has not been
  ;; found in the loadpath!"
  ;; So added https://github.com/math-comp/bigenough.
  (package
    (name "coq-mathcomp-bigenough")
    (version "1.0.1")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/math-comp/bigenough")
                    (commit version)
                    (recursive? #t)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "02f4dv4rz72liciwxb2k7acwx6lgqz4381mqyq5854p3nbyn06aw"))))
    (build-system gnu-build-system)
    (arguments
     `( ;"No rule to make target 'test'. Stop."
       ;; No references to tests in Makefile.common.
       ;; It doesn't appear as though tests will be included
       ;; by the packaged project in the future.
       #:tests? #f
       #:make-flags ,#~(list (string-append "COQBIN="
                                            #$(this-package-input "coq-core")
                                            "/bin/")
                             (string-append "COQMF_COQLIB="
                                            (assoc-ref %outputs "out")
                                            "/lib/ocaml/site-lib/coq")
                             (string-append "COQLIBINSTALL="
                                            (assoc-ref %outputs "out")
                                            "/lib/coq/user-contrib"))
       #:phases (modify-phases %standard-phases
                  (delete 'configure))))
    (propagated-inputs (list coq coq-core coq-mathcomp which))
    (home-page "https://math-comp.github.io/")
    (synopsis "Small library to do epsilon - N reasoning")
    (description
     "The package contains a package to reasoning with big enough
objects (mostly natural numbers).  This package is essentially for
backward compatibility purposes as @code{bigenough} will be subsumed by the
near tactics.  The formalization is based on the Mathematical
Components library.")
    (license license:cecill-b)))

(define-public coq-mathcomp-analysis
  (package
    (name "coq-mathcomp-analysis")
    ;;(version "0.5.3")
    (version "0.5.4")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/math-comp/analysis")
                    (commit version)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                ;; hash for v0.5.3
                ;;"16bv2kxm6nrgfm9lp88sls1vqs26d4m3fxbccmy328ak5srcbn6l"
                ;; hash for v0.5.4
                "1l1yaxbmqr4li8x7g51q98a6v383dnf94lw1b74ccpwqz9qybz9m"
                ))))
    (build-system gnu-build-system)
    (arguments
     `( ;No rule to make target 'check'. Stop.
       ;; Makefile.common has no references to tests.
       ;; There are also no references to tests found after
       ;; running the following commands in the top
       ;; directory of the cloned repo:
       ;; find -type d | grep -i test
       ;; rg test
       ;; Checking the git log, we find: "Add test suite for
       ;; joins and several fixes".
       ;;
       ;; If tests are included, this quote suggests that they
       ;; would be part of the source files themselves,
       ;; and the tests would be run as part of the build
       ;; process.
       #:tests? #f
       #:make-flags ,#~(list (string-append "COQBIN="
                                            #$(this-package-input "coq-core")
                                            "/bin/")
                             (string-append "COQBININSTALL="
                                            (assoc-ref %outputs "out") "/bin/")
                             (string-append "DESTDIR="
                                            (assoc-ref %outputs "out"))
                             (string-append "COQMF_COQLIB="
                                            (assoc-ref %outputs "out")
                                            "/lib/ocaml/site-lib/coq")
                             (string-append "COQLIBINSTALL="
                                            (assoc-ref %outputs "out")
                                            "/lib/coq/user-contrib"))
       #:phases (modify-phases %standard-phases
                  (delete 'configure)
                  (replace 'build
                    (lambda* (#:key make-flags #:allow-other-keys)
                      ;; (apply invoke "make" "build" make-flags)
                      (apply invoke "make" make-flags)
                      )))))
    (inputs (list coq
                  coq-stdlib
                  coq-mathcomp
                  coq-mathcomp-finmap
                  coq-mathcomp-hierarchy-builder
                  coq-elpi
                  coq-mathcomp-bigenough
                  coq-core
                  which
                  python))
    (synopsis "Real analysis for the Coq proof assistant")
    (description
     "This repository contains an experimental library for
real analysis for the Coq proof-assistant, using the Mathematical
Components library.")
    (home-page "https://math-comp.github.io/")
    (license license:cecill-c)))

;;; Python
;; (define-public python-import-everything
;;   (package
;;   (name "python-import-everything")
;;   (version "0.0.1")
;;   (source (origin
;;             (method url-fetch)
;;             (uri (pypi-uri "import-everything" version))
;;             (sha256
;;              (base32
;;               "1cq45i421bksg2lwwf5xddp30v0z95qzh2g6dxi1ky989lgxvlv3"))))
;;   (build-system python-build-system)
;;   (inputs (list python python-pypa-build python-pytest))
;;   (arguments
;;      (substitute-keyword-arguments (package-arguments python-jsonschema)
;;        ((#:phases phases)
;;        #~(modify-phases #$phases
;;                       (replace 'build
;;                                (lambda _
;;                                  ;; ZIP does not support timestamps before 1980.
;;                 (setenv "SOURCE_DATE_EPOCH" "315532800")
;;                 (invoke "python" "-m" "build" "--wheel"
;;                 "--no-isolation" ".")

;;                 ))
;;                       (replace 'install
;;               (lambda* (#:key outputs #:allow-other-keys)
;;                 (let ((whl (car (find-files "dist" "\\.whl$"))))
;;                   (invoke "pip" "--no-cache-dir" "--no-input"
;;                           "install" "--no-deps" "--prefix" #$output whl))))
;;               ))))
;;   (home-page "https://github.com/profMagija/everything")
;;   (synopsis "A module containing everything")
;;   (description "This package provides a module containing everything")
;;   (license #f)))
(define-public python-version
  ;; No version tags available; just using bare commit instead.
  (let ((commit "5232eea250ab72cc5cb72b0b75efb35d2192b906"))
    (package
      (name "python-python-version")
      (version "0.0.2")
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://gitlab.com/halfak/python_version")
                      (commit commit)))
                (sha256
                 (base32
                  "0w210559ypdynlj9yn40m9awzkaknwrf682i99hswl7h66sdgh0h"))))
      (build-system python-build-system)
      (home-page "https://gitlab.com/halfak/python_version")
      (synopsis "Provides a simple utility for checking the python version.")
      (description
       "This package provides a simple utility for checking the python version.")
      ;; MIT License
      (license license:expat))))



(define-public python-editables
  (package
    (name "python-editables")
    (version "0.3")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/pfmoore/editables")
                    (commit version)))
              (sha256
               (base32
                "1gbfkgzmrmbd4ycshm09fr2wd4f1n9gq7s567jgkavhfkn7s2pn1"))))
    (build-system python-build-system)
    (home-page "https://github.com/pfmoore/editables")
    (synopsis "Editable installations")
    (description "Editable installations")
    (license license:expat)))

(define-public python-pluggy-1.0
  (package
    (inherit python-pluggy)
    (name "python-pluggy-1.0")
    (version "1.0.0")
    (source (origin
              ;; Won't build from github tarballs, throws error:
              ;; "LookupError: setuptools-scm was unable to detect version for '/tmp/guix-build-python-pluggy-1.0-1.0.0.drv-0/source'."
              (method url-fetch)
              (uri (pypi-uri "pluggy" version))
              (sha256
               (base32
                "0n8iadlas2z1b4h0fc73b043c7iwfvx9rgvqm1azjmffmhxkf922"))))
    (inputs (list python
                  python-pypa-build
                  python-pytest
                  python-setuptools-scm
                  python-setuptools
                  python-wheel))))

;; (define-public python-hatch-vcs
;;   ;; Tags are messed up; just use the commit itself.
;;   (let ((commit "367daedb23ba906f3e0714c64392fdd6ffa69ab2"))
;;     (package
;;       (name "python-hatch-vcs")
;;       (version "0.2.0")
;;       (source (origin
;;                 (method git-fetch)
;;                 (uri (git-reference
;;                       (url "https://github.com/ofek/hatch-vcs")
;;                       (commit commit)))
;;                 (sha256
;;                  (base32
;;                   "0nlnv32jqiz8ikc013h5simmiqqg0qa7pm0qcbd8yiqq1p43iw05"))))
;;       (build-system python-build-system)
;;       (inputs (list python
;;                     python-pypa-build
;;                     python-pathspec-0.10.1
;;                     python-pluggy-1.0
;;                     python-editables
;;                     python-pytest
;;                     git))
;;       (propagated-inputs (list python-hatchling-bootstrap python-setuptools-scm-7)) ;python-setuptools-scm-6.4 minimum
;;       (arguments
;;        (substitute-keyword-arguments (package-arguments python-jsonschema)
;;          ((#:phases phases)
;;           #~(modify-phases #$phases
;;               (replace 'build
;;                 (lambda _
;;                   (setenv "SOURCE_DATE_EPOCH" "315532800")
;;                   (invoke "python"
;;                           "-m"
;;                           "build"
;;                           "--wheel"
;;                           "--no-isolation"
;;                           ".")))
;;               (replace 'install
;;                 (lambda* (#:key outputs #:allow-other-keys)
;;                   (let ((whl (car (find-files "dist" "\\.whl$"))))
;;                     (invoke "pip"
;;                             "--no-cache-dir"
;;                             "--no-input"
;;                             "install"
;;                             "--no-deps"
;;                             "--prefix"
;;                             #$output
;;                             whl))))
;;               (replace 'check
;;                 (lambda* (#:key tests? #:allow-other-keys)
;;                   (when tests?
;;                     (invoke "pytest" "-vvv"))))))))
;;       (home-page "")
;;       (synopsis "Hatch plugin for versioning with your preferred VCS")
;;       (description "Hatch plugin for versioning with your preferred VCS")
;;       (license #f))))

(define-public python-setuptools-scm-7
  ;; Another broken python release. Ugh.
  (let ((commit "c4d37004ab0a16c2cacdc58ef06b36956db02a9f"))
    (package
      (name "python-setuptools-scm")
      (version "7.0.5")
      (source (origin
                ;; Won't build with git. Fails with error:
                ;; "ERROR Backend subproccess exited when trying to invoke
                ;; get_requires_for_build_wheel"
                (method url-fetch)
                (uri (pypi-uri "setuptools_scm" version))
                (sha256
                 (base32
                  "0i28zghzdzzkm9w8rrjwphggkfs58nh6xnqsjhmqjvqxfypi67h3"))

                ))
      (build-system python-build-system)
      (propagated-inputs (list python-importlib-metadata python-packaging
                               python-setuptools python-tomli
                               python-typing-extensions))
      (native-inputs (list python
                           python-pypa-build
                           python-pytest
                           python-virtualenv
                           git-minimal
                           mercurial))
      (home-page "https://github.com/pypa/setuptools_scm/")
      (synopsis "the blessed package to manage your versions by scm tags")
      (description "the blessed package to manage your versions by scm tags")
      (license license:expat))))

(define-public python-pprintpp
  ;; Another broken python version
  (let ((commit "7ede6da1f3062bbfb32ee04353d675a5bff185e0"))
    (package
      (name "python-pprintpp")
      (version "0.3.0")
      (source (origin
                ;; No version given in the github repo
                ;; https://github.com/wolever/pprintpp.
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/wolever/pprintpp")
                      (commit commit)))
                (sha256
                 (base32
                  "0nk935m3ig8sc32laqbh698vwpk037yw27gd3nvwwzdv42jal2li"))

                ))
      (inputs (list python
                    python-pypa-build
                    python-pytest
                    python-hypothesis
                    python-setuptools
                    python-wheel
                    python-nose
                    python-parameterized))
      (build-system python-build-system)
      (arguments
       (substitute-keyword-arguments (package-arguments python-jsonschema)
         ((#:phases phases)
          #~(modify-phases #$phases
              (replace 'build
                (lambda _
                  (setenv "SOURCE_DATE_EPOCH" "315532800")
                  (invoke "python"
                          "-m"
                          "build"
                          "--wheel"
                          "--no-isolation"
                          ".")))
              (replace 'install
                (lambda* (#:key outputs #:allow-other-keys)
                  (let ((whl (car (find-files "dist" "\\.whl$"))))
                    (invoke "pip"
                            "--no-cache-dir"
                            "--no-input"
                            "install"
                            "--no-deps"
                            "--prefix"
                            #$output
                            whl))))
              (replace 'check
                (lambda* (#:key tests? #:allow-other-keys)
                  (when tests?
                    (invoke "python" "test.py"))))))))

      (home-page "https://github.com/wolever/pprintpp")
      (synopsis "A drop-in replacement for pprint that's actually pretty")
      (description
       "This package provides a drop-in replacement for pprint that's actually pretty")
      (license license:bsd-3))))

(define-public python-icdiff
  (package
    (name "python-icdiff")
    (version "2.0.5")
    (source (origin
              ;; (method url-fetch)
              ;; (uri (pypi-uri "icdiff" version))
              ;; (sha256
              ;; (base32
              ;; "1bhbcc8mqvhdswfarl12x57yyzpw7dnkhsfv5fhy1ds8irr4plim"))
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/jeffkaufman/icdiff")
                    (commit (string-append "release-" version))))
              (sha256
               (base32
                "14gr9j2h7sfw47pwfzspm4zinywhqmzm4a0qz5c2k9wbixz120a4"))

              ))
    (build-system python-build-system)
    (home-page "http://www.jefftk.com/icdiff")
    (synopsis "improved colored diff")
    (description "improved colored diff")
    (license #f)))

(define-public python-pytest-icdiff
  (package
    (name "python-pytest-icdiff")
    (version "0.6")
    (source (origin
              ;; Tests fail in git version, but not in pypi version.
              (method url-fetch)
              (uri (pypi-uri "pytest-icdiff" version))
              (sha256
               (base32
                "1b8vzn2hvv6x25w1s446q1rfsbdik617lzpal3qb94x8a12yzwg8"))))
    (build-system python-build-system)
    (propagated-inputs (list python python-pypa-build python-icdiff
                             python-pprintpp python-pytest))
    (home-page "https://github.com/hjwp/pytest-icdiff")
    (synopsis "use icdiff for better error messages in pytest assertions")
    (description "use icdiff for better error messages in pytest assertions")
    (license #f)))

(define-public python-hatch-fancy-pypi-readme
  (package
    (name "python-hatch-fancy-pypi-readme")
    ;;(version "22.3.0")
    (version "22.8.0")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "hatch_fancy_pypi_readme" version))
              (sha256
               (base32
                ;;"1ykfz1sbz58xbjw5k9xpmn5r6ji16w8vag47j8f969bqy3w52ikx"
                "0sn2wsfbpsbf2mqhjvw62h1cfy5mz3d7iqyqvs5c20cnl0n2i4fs"))))
    (build-system python-build-system)
    (propagated-inputs (list python-hatchling-bootstrap python-tomli
                             python-typing-extensions))
    (native-inputs (list python
                         python-pypa-build
                         python-pathspec-0.10.1
                         python-pluggy-1.0
                         python-editables
                         python-hatchling-bootstrap
                         python-wheel
                         python-pytest
                         python-pytest-icdiff))
    (arguments
     `(#:phases (modify-phases %standard-phases
                  (add-before 'build 'disable-broken-tests
                    (lambda _
                      ;; Skip the tests for "building". Guix already does this,
                      ;; so we don't need to test it for any Guix package.
                      (chdir "tests")
                      (invoke "sed" "-i"
                       "11ipytest.skip('No need to test building, guix does this already', allow_module_level=True)"
                       "test_end_to_end.py")
                      (chdir "../")))
                  ;; XXX: PEP 517 manual build/install procedures copied from
                  ;; python-isort.
                  (replace 'build
                    (lambda _
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "python"
                              "-m"
                              "build"
                              "--wheel"
                              "--no-isolation"
                              ".")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl))))
                  (replace 'check
                    (lambda _
                      (invoke "pytest" "-vv"))))))
    (home-page "")
    (synopsis "Fancy PyPI READMEs with Hatch")
    (description "Fancy PyPI READMEs with Hatch")
    (license #f)))

;; (define-public python-jsonschema-4.6
;;   (package
;;     (inherit python-jsonschema)
;;     (name "python-jsonschema-4.6")
;;     (version "4.15.0")
;;     (source (origin
;;               (method url-fetch)
;;               (uri (pypi-uri "jsonschema" version))
;;               (sha256
;;                (base32
;;                 "07pyh8g4csapkfjgjww7vkxwvh1qwxwqxz82wm2b1kmxj69rgx11"))))

;;     (native-inputs (list python-pypa-build
;;                          python-twisted
;;                          python-hatchling-bootstrap
;;                          python-pathspec
;;                          python-pluggy-1.0
;;                          python-editables
;;                          python-hatch-vcs
;;                          python-setuptools-scm-7
;;                          python-hatch-fancy-pypi-readme))
;;     (propagated-inputs (list python-attrs
;;                              python-importlib-metadata
;;                              python-pyrsistent
;;                              python-typing-extensions
;;                              python-hatch-vcs
;;                              python-setuptools-scm-7))
;;     (arguments
;;      (substitute-keyword-arguments (package-arguments python-jsonschema-next)
;;        ))))

(define-public python-pprintpp
  ;; Git version tags are inaccurate for this package; use the
  ;; bare commit.
  (let ((commit "7ede6da1f3062bbfb32ee04353d675a5bff185e0")
        (revision "1"))
    (package
      (name "python-pprintpp")
      (version (git-version "0.3.0" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/wolever/pprintpp")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "0nk935m3ig8sc32laqbh698vwpk037yw27gd3nvwwzdv42jal2li"))))
      (inputs (list python-pypa-build python-hypothesis python-wheel
                    python-parameterized))
      (native-inputs (list python-pytest python-nose))
      (build-system python-build-system)
      (arguments
       (list #:phases #~(modify-phases %standard-phases
                          (replace 'build
                            (lambda _
                              (setenv "SOURCE_DATE_EPOCH" "315532800")
                              (invoke "python"
                                      "-m"
                                      "build"
                                      "--wheel"
                                      "--no-isolation"
                                      ".")))
                          (replace 'install
                            (lambda* (#:key outputs #:allow-other-keys)
                              (let ((whl (car (find-files "dist" "\\.whl$"))))
                                (invoke "pip"
                                        "--no-cache-dir"
                                        "--no-input"
                                        "install"
                                        "--no-deps"
                                        "--prefix"
                                        #$output
                                        whl))))
                          (replace 'check
                            (lambda* (#:key tests? #:allow-other-keys)
                              (when tests?
                                (invoke "python" "test.py")))))))
      (home-page "https://github.com/wolever/pprintpp")
      (synopsis "Python pretty-printer")
      (description
       "This package is a printer for Python which pretty-prints structures.
It also attempts to print Unicode characters without escaping them.")
      (license license:bsd-3))))

(define-public python-pluggy-1.0
  (package
    (inherit python-pluggy)
    (name "python-pluggy")
    (version "1.0.0")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "pluggy" version))
              (sha256
               (base32
                "0n8iadlas2z1b4h0fc73b043c7iwfvx9rgvqm1azjmffmhxkf922"))))
    (inputs (list python-pypa-build python-wheel))
    (native-inputs (list python-pytest python-setuptools-scm))))

(define-public python-setuptools-scm-7
  (package
    (inherit python-setuptools-scm)
    (version "7.0.5")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "setuptools_scm" version))
              (sha256
               (base32
                "0i28zghzdzzkm9w8rrjwphggkfs58nh6xnqsjhmqjvqxfypi67h3"))))
    (build-system python-build-system)
    (arguments
     `( ;Disabled tests to avoid extra dependencies.
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  ;; Disabled sanity check to avoid extra dependencies.
                  (delete 'sanity-check))))
    (propagated-inputs (list python-packaging-bootstrap python-tomli))))

(define-public python-pathspec-0.10.1
(package
  (name "python-pathspec")
  (version "0.10.1")
  (source ;; (origin
          ;;   (method url-fetch)
          ;;   (uri (pypi-uri "pathspec" version))
          ;;   (sha256
          ;;    (base32
   ;;     "0g9jhhhf3zmrnvzvjjd2yhizsb6i93hmlszb09wixlr1nrhn3kks")))
   (origin
     (method git-fetch)
     (uri (git-reference
       (url
        "https://github.com/cpburnz/python-pathspec")
       (commit (string-append "v" version))))
       (sha256
        (base32 "0sgzh7ad1x098d0rln01f0qabpa7mnp26863isncbiyqsxh1gaxp"))))
  (build-system python-build-system)
  (home-page "https://github.com/cpburnz/python-pathspec")
  (synopsis
   "Utility library for gitignore style pattern matching of file paths.")
  (description
   "Utility library for gitignore style pattern matching of file paths.")
  (license license:mpl2.0)))

;; This depends on packages in python-xyz.scm:
;; python-version, python-importlib-metadata, python-pathspec,
;; python-pluggy-1.0, and python-platformdirs.
(define-public python-hatchling-bootstrap
  (package
    (name "python-hatchling-bootstrap")
    (version "1.10.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/pypa/hatch")
                    (commit (string-append "hatchling-v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                ;;"1q25kqw71g8mjwfjz9ph0iigdqa26zzxgmqm0v0bp0z1j8rcl237"
                ;;"1yqkwck2aihfdm9ljv5q4nygmmqyp35xwyp8lqn2f4vq9p6njq3c"
                "0ahx62w711a2vnb91ahqxrw8yi0gq0kfch3fk6akzngd13376czj" ;; github weirdness.
                ))))
    ;; python-pypa-build needed for bootstrapping.
    ;; Otherwise we get a circular reference:
    ;; python-hatchling trying to build itself, without
    ;; first having hatchling installed.
    (inputs (list python-pypa-build
                  python-editables
                  python-importlib-metadata
                  python-version
                  python-packaging-next
                  python-pathspec-0.10.1
                  python-pluggy-1.0 ;TODO: Not detected by pytest?
                  python-tomli
                  python-platformdirs))
    (build-system python-build-system)
    (arguments
     `( ;Tests depend on module python-hatch, which this
       ;; is bootstrapping.
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  (replace 'build
                    (lambda _
                      (chdir "backend")
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "python"
                              "-m"
                              "build"
                              "--wheel"
                              "--no-isolation"
                              ".")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl)))))))
    (home-page "https://ofek.dev/projects/hatch/")
    (synopsis "Bootstrap binaries to build @code{python-hatch}")
    (description "Bootstrap binaries to build @code{python-hatch}")
    ;; MIT License
    (license license:expat)))

(define-public python-hatch
  (package
    (name "python-hatch")
    (version "1.5.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/pypa/hatch")
                    (commit (string-append "hatch-v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "030yi9hw50mn899pq073lw2a55r57skl2g9agjp3b4l95f3nay30"))))
    (inputs (list python-pypa-build
                  python-editables
                  python-importlib-metadata
                  python-version
                  python-packaging-next
                  python-pathspec
                  python-pluggy-1.0 ;TODO: Not detected by pytest?
                  python-hatchling-bootstrap
                  python-tomli
                  python-platformdirs
                  python-rich
                  python-tomli-w))
    (build-system python-build-system)
    (arguments
     `( ;Tests appear to be written such that the input python-pluggy-1.0 is
       ;; not detected.
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  (replace 'build
                    (lambda _
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "hatchling" "build")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl))))
                  (replace 'check
                    (lambda* (#:key tests? #:allow-other-keys)
                      (when tests?
                        (chdir "tests")
                        (invoke "pytest" "-vv"))))
                  ;; Can't have hatch as a requirement of itself.
                  (delete 'sanity-check))))
    (home-page "https://ofek.dev/projects/hatch/")
    (synopsis "Python build system with project generation")
    (description
     "Python build system with project generation.  It also defines a specific
syntax in @code{toml} files to check for dependencies.")
    ;; MIT License
    (license license:expat)))

(define-public python-hatch-vcs
  ;; Tags are not accurate; just use the commit itself.
  (let ((commit "367daedb23ba906f3e0714c64392fdd6ffa69ab2")
        (revision "1"))
    (package
      (name "python-hatch-vcs")
      (version (git-version "0.2.0" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/ofek/hatch-vcs")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "0nlnv32jqiz8ikc013h5simmiqqg0qa7pm0qcbd8yiqq1p43iw05"))))
      (build-system python-build-system)
      (inputs (list python-pypa-build
                    python-pathspec-0.10.1
                    python-pluggy-1.0
                    python-editables
                    git
                    python-hatchling-bootstrap
                    python-typing-extensions))
      (native-inputs (list python-pytest
                           ;; python-setuptools-scm-6.4 minimum
                           python-setuptools-scm-7))
      (arguments
       (list #:phases #~(modify-phases %standard-phases
                          (replace 'build
                            (lambda _
                              (setenv "SOURCE_DATE_EPOCH" "315532800")
                              (invoke "python"
                                      "-m"
                                      "build"
                                      "--wheel"
                                      "--no-isolation"
                                      ".")))
                          (replace 'install
                            (lambda* (#:key outputs #:allow-other-keys)
                              (let ((whl (car (find-files "dist" "\\.whl$"))))
                                (invoke "pip"
                                        "--no-cache-dir"
                                        "--no-input"
                                        "install"
                                        "--no-deps"
                                        "--prefix"
                                        #$output
                                        whl))))
                          (replace 'check
                            (lambda* (#:key tests? #:allow-other-keys)
                              (when tests?
                                (invoke "pytest" "-vvv"))))))) ;)
      (home-page "https://ofek.dev/projects/hatch/")
      (synopsis "Plugin for @code{python-hatch} to include versions")
      (description
       "This plugin defines a version-control syntax for use with
@code{toml} files intended for use with @code{python-hatch}.")
      ;; MIT License
      (license license:expat))))

(define-public python-pytest-icdiff
  (package
    (name "python-pytest-icdiff")
    (version "0.6")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "pytest-icdiff" version))
              (sha256
               (base32
                "1b8vzn2hvv6x25w1s446q1rfsbdik617lzpal3qb94x8a12yzwg8"))))
    (build-system python-build-system)
    (propagated-inputs (list python-pypa-build python-icdiff python-pprintpp))
    (native-inputs (list python-pytest))
    (home-page "https://github.com/hjwp/pytest-icdiff")
    (synopsis "Colored diffs using @code{python-icdiff} for pytest output")
    (description
     "This package uses @code{python-icdiff} to add color to the output of
pytest assertions.")
    (license (license:non-copyleft "LICENSE"))))

;; (define-public python-hatch-fancy-pypi-readme
;;   (package
;;     (name "python-hatch-fancy-pypi-readme")
;;     (version "22.8.0")
;;     (source (origin
;;               (method url-fetch)
;;               (uri (pypi-uri "hatch_fancy_pypi_readme" version))
;;               (sha256
;;                (base32
;;                 "1ykfz1sbz58xbjw5k9xpmn5r6ji16w8vag47j8f969bqy3w52ikx"))))
;;     (build-system python-build-system)
;;     (propagated-inputs (list python-tomli python-typing-extensions))
;;     (native-inputs (list python-pypa-build
;;                          python-pathspec
;;                          python-pluggy-1.0
;;                          python-editables
;;                          python-hatch
;;                          python-hatchling-bootstrap
;;                          python-wheel
;;                          python-pytest
;;                          python-pytest-icdiff))
;;     (arguments
;;      `(#:phases (modify-phases %standard-phases
;;                   (add-before 'build 'disable-broken-tests
;;                     (lambda _
;;                       ;; Skip the tests for "building". Guix already does this,
;;                       ;; so we don't need to test it for this package.
;;                       (chdir "tests")
;;                       (invoke "sed" "-i"
;;                               "11ipytest.skip('No need to test\
;;  building; guix does this already', allow_module_level=True)"
;;                               "test_end_to_end.py")
;;                       (chdir "../")))
;;                   ;; XXX: PEP 517 manual build/install procedures copied from
;;                   ;; python-isort.
;;                   (replace 'build
;;                     (lambda _
;;                       ;; ZIP does not support timestamps before 1980.
;;                       (setenv "SOURCE_DATE_EPOCH" "315532800")
;;                       (invoke "python"
;;                               "-m"
;;                               "build"
;;                               "--wheel"
;;                               "--no-isolation"
;;                               ".")))
;;                   (replace 'install
;;                     (lambda* (#:key outputs #:allow-other-keys)
;;                       (let ((whl (car (find-files "dist" "\\.whl$"))))
;;                         (invoke "pip"
;;                                 "--no-cache-dir"
;;                                 "--no-input"
;;                                 "install"
;;                                 "--no-deps"
;;                                 "--prefix"
;;                                 (assoc-ref %outputs "out")
;;                                 whl))))
;;                   (replace 'check
;;                     (lambda* (#:key tests? #:allow-other-keys)
;;                       (when tests?
;;                         (invoke "pytest" "-vv")))))))
;;     (home-page
;;      "https://github.com/hynek/hatch-fancy-pypi-readme")
;;     (synopsis "Syntax for styling PyPI READMEs")
;;     (description
;;      "Defines a syntax for the python-hatch build system, intended for styling
;; READMEs for PyPI.")
;;     ;; MIT License
;;     (license license:expat)))

;; Has to be done manually. DO NOT copy and paste this one.
(define-public python-jsonschema-4.15
  (package
    (inherit python-jsonschema-next)
    (version "4.16.0")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "jsonschema" version))
              (sha256
               (base32
  ;; old pypi hash
                ;; ;;"07pyh8g4csapkfjgjww7vkxwvh1qwxwqxz82wm2b1kmxj69rgx11"
                ;; new pypi hash
                "08sbw5fn19vn8x7c216gkczyzd575702yx2vmqdrgxpgfvq5jl0n"))))
    (native-inputs (list python-pypa-build
                         python-twisted
                         python-hatch
                         python-hatchling-bootstrap
                         python-pathspec-0.10.1
                         python-pluggy-1.0
                         python-editables
                         python-hatch-vcs
                         python-setuptools-scm-7
                         python-hatch-fancy-pypi-readme))
    (propagated-inputs (list python-attrs
                             python-importlib-metadata
                             python-pyrsistent
                             python-typing-extensions
                             python-hatch-vcs))
    (home-page "https://github.com/python-jsonschema/jsonschema")))

coq-mathcomp-analysis
--8<---------------cut here---------------end--------------->8---

channels.scm
--8<---------------cut here---------------start------------->8---
;;; This module extends GNU Guix and is licensed under the same terms, those
;;; of the GNU GPL version 3 or (at your option) any later version.
;;;
;;; Copyright © 2022 Garek Dyszel <garekdyszel@disroot.org>

(list
 ;; guix
 (channel
  (name 'guix)
  ;;(url "https://git.savannah.gnu.org/git/guix.git")
  (url "https://github.com/guix-mirror/guix")
  (introduction
   (make-channel-introduction
    "9edb3f66fd807b096b48283debdcddccfea34bad"
    (openpgp-fingerprint
     "BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA")))
  (commit "9f391b90faca02ca97c5018d6c095ecdaa1a94a7")) ;; The commit
 ;; just before the upgrade to Coq 8.16!

 ;; The channel that contains coq-mathcomp-analysis package
 ;; definitions. 
 (channel
  (name 'coq-mathcomp-analysis-packages)
  ;;(url
  ;;"/home/chips/home/code/coq-my-theories/mathcomp-extra-packages"
  (url
"./mathcomp-extra-packages")))
--8<---------------cut here---------------end--------------->8---

guix-manifest.scm
--8<---------------cut here---------------start------------->8---
;;; This module extends GNU Guix and is licensed under the same terms, those
;;; of the GNU GPL version 3 or (at your option) any later version.
;;;
;;; Copyright © 2022 Garek Dyszel <garekdyszel@disroot.org>

(use-modules
 (guix packages)
 (gnu packages coq)
 (coq-mathcomp-analysis))

(packages->manifest (list coq coq-stdlib coq-mathcomp coq-mathcomp-finmap coq-mathcomp-hierarchy-builder coq-elpi coq-mathcomp-bigenough coq-core coq-mathcomp-analysis))
--8<---------------cut here---------------end--------------->8---

[bug#58310] [PATCH 03/14] gnu: Add python-setuptools-scm-7.

[zimoun]

Hi,

CC: python team

On mer., 05 oct. 2022 at 13:41, Garek Dyszel via Guix-patches via <guix-patches@gnu.org> wrote:

> +(define-public python-setuptools-scm-7
> +  (package
> +    (inherit python-setuptools-scm)
> +    (version "7.0.5")

The issue with this is then

    guix install python python-setuptools-scm

will install python-setuptools-scm@7 and not the current one at 6.3.2.
Since I am not an expert on this setuptools_scm, the question is: is it
an issue?  For instance, it can be for python-numpy so the term ’-next’
is appended to the name.

Here, we could also append ’-next’, WDYT?

Cheers,
simon

[bug#58310] [PATCH 04/14] gnu: Add python-hatchling-bootstrap.

[zimoun]

Hi,

CC: python team

On mer., 05 oct. 2022 at 13:41, Garek Dyszel via Guix-patches via <guix-patches@gnu.org> wrote:
> * gnu/packages/python-build.scm (python-hatchling-bootstrap): New variable.
> ---
>  gnu/packages/python-build.scm | 63 +++++++++++++++++++++++++++++++++++
>  1 file changed, 63 insertions(+)
>
> diff --git a/gnu/packages/python-build.scm b/gnu/packages/python-build.scm
> index e17cde16d9..f90d23874f 100644
> --- a/gnu/packages/python-build.scm
> +++ b/gnu/packages/python-build.scm
> @@ -516,3 +516,66 @@ (define-public python-editables
>  ``editable mode''.  In other words, changes to the package source will be
>  reflected in the package visible to Python, without needing a reinstall.")
>      (license license:expat)))
> +
> +;; This depends on packages in python-xyz.scm:
> +;; python-version, python-importlib-metadata, python-pathspec,
> +;; python-pluggy-1.0, and python-platformdirs.
> +(define-public python-hatchling-bootstrap
> +  (package
> +    (name "python-hatchling-bootstrap")
> +    (version "1.10.0")
> +    (source (origin
> +              (method git-fetch)
> +              (uri (git-reference
> +                    (url "https://github.com/pypa/hatch")
> +                    (commit (string-append "hatchling-v" version))))
> +              (file-name (git-file-name name version))
> +              (sha256
> +               (base32
> +                ;;"1q25kqw71g8mjwfjz9ph0iigdqa26zzxgmqm0v0bp0z1j8rcl237"
> +                "1yqkwck2aihfdm9ljv5q4nygmmqyp35xwyp8lqn2f4vq9p6njq3c"))))
> +    ;; python-pypa-build needed for bootstrapping.
> +    ;; Otherwise we get a circular reference:
> +    ;; python-hatchling trying to build itself, without
> +    ;; first having hatchling installed.
> +    (inputs (list python-pypa-build
> +                  python-editables
> +                  python-importlib-metadata
> +                  python-version
> +                  python-packaging-next
> +                  python-pathspec
> +                  python-pluggy-1.0 ;TODO: Not detected by pytest?
> +                  python-tomli
> +                  python-platformdirs))

The issue here is that many dependencies are from the module (gnu
packages python-xyz).  Well, moving this python-hatchling-bootstrap and
the next patch adding python-hatch to python-xyz does not look like the
correct home.  And dragging these dependencies to python-build neither.

What could be the best solution here?


Cheers,
simon

[bug#58310] [PATCH 03/14] gnu: Add python-setuptools-scm-7.

[Lars-Dominik Braun]

Hi,

> Since I am not an expert on this setuptools_scm, the question is: is it
> an issue?  For instance, it can be for python-numpy so the term ’-next’
> is appended to the name.
as long as setuptools_scm’s dependencies are compatible and it does
not break current behavior – I don’t see any breaking changes in
the ChangeLog – the -next is not justified imo.

Lars

[bug#58310] [PATCH 04/14] gnu: Add python-hatchling-bootstrap.

[Lars-Dominik Braun]

Hi,

> The issue here is that many dependencies are from the module (gnu
> packages python-xyz).  Well, moving this python-hatchling-bootstrap and
> the next patch adding python-hatch to python-xyz does not look like the
> correct home.  And dragging these dependencies to python-build neither.
I think hatchling can go to python-build, since it
contains a PEP 517 build system, but hatchling should go to
python-xyz. python-hatchling-bootstrap should not be used anywhere,
but build a proper python-hatchling instead. Also hatchling has no
dependencies. These are for hatch.

The entire patchset should also use the pyproject build system where possible.

Lars

[bug#58310] [PATCH 03/14] gnu: Add python-setuptools-scm-7.

[zimoun]

Hi Lars,

On Thu, 03 Nov 2022 at 18:22, Lars-Dominik Braun <lars@6xq.net> wrote:

>> Since I am not an expert on this setuptools_scm, the question is: is it
>> an issue?  For instance, it can be for python-numpy so the term ’-next’
>> is appended to the name.
>
> as long as setuptools_scm’s dependencies are compatible and it does
> not break current behavior – I don’t see any breaking changes in
> the ChangeLog – the -next is not justified imo.

The update of python-setuptools-scm from 6 to 7 is not possible without
going via core-updates, no?

--8<---------------cut here---------------start------------->8---
$ guix refresh -l python-setuptools-scm | cut -f1 -d':'
Building the following 2406 packages would ensure 5564 dependent packages are rebuilt
--8<---------------cut here---------------end--------------->8---

Therefore, there are only two options for the patchset:

   1. try to build the patchset using the current v6 of python-setuptools-scm
or
   2. add v7 as a separated package

I have not tried #1.  About #2, if the name of this new package is not
tweaked, then it can be confusing to get v7 at the command line (or
specifications->manifest) when all the other Python stack is built using
v6; even if there is no incompatibilities between v6 and v7 according to
upstream notes.

Well, so you opinion is to keep the name for v7 as it is, right?


Cheers,
simon

[bug#58310] [PATCH 04/14] gnu: Add python-hatchling-bootstrap.

[zimoun]

Hi,

On Thu, 03 Nov 2022 at 18:26, Lars-Dominik Braun <lars@6xq.net> wrote:

>> The issue here is that many dependencies are from the module (gnu
>> packages python-xyz).  Well, moving this python-hatchling-bootstrap and
>> the next patch adding python-hatch to python-xyz does not look like the
>> correct home.  And dragging these dependencies to python-build neither.
> I think hatchling can go to python-build, since it
> contains a PEP 517 build system, but hatchling should go to
> python-xyz. python-hatchling-bootstrap should not be used anywhere,
> but build a proper python-hatchling instead. Also hatchling has no
> dependencies. These are for hatch.

Lars, I am sorry I am missed your advice about what is going where.  Is
your point to revamp a bit the bootstrap and put all in python-xyz?

> The entire patchset should also use the pyproject build system where possible.

Garek, do you want to give a try?


Cheers,
simon

[bug#58310] [PATCH 03/14] gnu: Add python-setuptools-scm-7.

[Lars-Dominik Braun]

Hi zimoun,

> The update of python-setuptools-scm from 6 to 7 is not possible without
> going via core-updates, no?
it’s just an addition and not replacing the current setuptools-scm,
if I see correctly.

Cheers,
Lars

[bug#58310] [PATCH 04/14] gnu: Add python-hatchling-bootstrap.

[Lars-Dominik Braun]

Hi,

> > I think hatchling can go to python-build, since it
> > contains a PEP 517 build system, but hatchling should go to
> > python-xyz. python-hatchling-bootstrap should not be used anywhere,
> > but build a proper python-hatchling instead. Also hatchling has no
> > dependencies. These are for hatch.
> 
> Lars, I am sorry I am missed your advice about what is going where.  Is
> your point to revamp a bit the bootstrap and put all in python-xyz?
sorry, misstyped. hatchling -> python-build.scm, hatch ->
python-xyz.scm. And hatchling’s dependencies actually belong to hatch,
not hatchling, so there should be no cycles with python-xyz.scm.

Cheers,
Lars

[bug#58310] [PATCH 03/14] gnu: Add python-setuptools-scm-7.

[zimoun]

Hi Lars,

On jeu., 03 nov. 2022 at 20:57, Lars-Dominik Braun <lars@6xq.net> wrote:

>> The update of python-setuptools-scm from 6 to 7 is not possible without
>> going via core-updates, no?
>
> it’s just an addition and not replacing the current setuptools-scm,
> if I see correctly.

Yes, so “guix install python-setuptools-scm” will install v7 and not the
version v6 used by default.  And it can be confusing, IMHO.


Cheers,
simon

[bug#58310] [PATCH 03/14] gnu: Add python-setuptools-scm-7.

[Lars-Dominik Braun]

Hi zimoun,

> Yes, so “guix install python-setuptools-scm” will install v7 and not the
> version v6 used by default.  And it can be confusing, IMHO.
yep, that’s unfortunate but how `guix install` works. It’d be nice
to be able to designate a “default” package. In this case I don’t
see a danger for breakage and setuptools-scm is afaik only a build-time
dependency.

Cheers,
Lars

[bug#58310] [PATCH 04/14] gnu: Add python-hatchling-bootstrap.

[Garek Dyszel via Guix-patches via]

Hi Lars,

At 20:59 2022-11-03 UTC+0900, Lars-Dominik Braun wrote:
> And hatchling’s dependencies actually belong to hatch,
> not hatchling, so there should be no cycles with python-xyz.scm.

It seems dependencies from python-xyz.scm are still required to enter
the build process for python-hatchling-bootstrap, even if hatchling does
not explicitly require them.

 (1) If we comment out the dependencies from python-xyz.scm, we get this
error:
--8<---------------cut here---------------start------------->8---
starting phase `build'
* Getting dependencies for wheel...

ERROR Missing dependencies:
	pathspec>=0.10.1
	pluggy>=1.0.0
--8<---------------cut here---------------end--------------->8---

(2) If we minimize the dependency list to the following, then
python-hatchling-bootstrap builds correctly:
--8<---------------cut here---------------start------------->8---
(inputs (list python-editables
              python-packaging-bootstrap
	      ;; Below from python-xyz.scm, can be moved to python-build.scm
	      python-pathspec-0.10.1
	      ;; Below from python-xyz.scm, can be moved to python-build.scm
	      python-pluggy-1.0
	      python-tomli))
--8<---------------cut here---------------end--------------->8---
Changing the build system to (pyproject-build-system) produces the same
results.

Since python-pluggy-1.0 and python-pathspec depend only on packages
defined in python-build.scm, I propose moving them to python-build.scm.

What do you think?

Garek

---
Revised python-hatchling-boostrap definition (in case it is of
interest):
--8<---------------cut here---------------start------------->8---
(define-public python-hatchling-bootstrap
  (package
    (name "python-hatchling-bootstrap")
    (version "1.10.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/pypa/hatch")
                    (commit (string-append "hatchling-v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0ahx62w711a2vnb91ahqxrw8yi0gq0kfch3fk6akzngd13376czj"))))
    ;; python-pypa-build needed for bootstrapping.
    ;; Otherwise we get a circular reference:
    ;; python-hatchling trying to build itself, without
    ;; first having hatchling installed.
    (inputs (list python-editables
                  python-packaging-bootstrap
                  ;; Below from python-xyz.scm, can be moved to python-build.scm
                  python-pathspec-0.10.1
                  ;; Below from python-xyz.scm, can be moved to python-build.scm
                  python-pluggy-1.0
                  python-tomli))
    (build-system pyproject-build-system)
    (arguments
     `(;; Tests depend on module python-hatch, which this
       ;; is bootstrapping.
       #:tests? #f
       #:phases
       ;; Test for pyproject-build-system. This pre-build phase fails.
       ;;
       ;; (modify-phases %standard-phases
       ;;   (add-before 'build 'chdir-to-backend
       ;;     (lambda _
       ;;       (chdir "backend"))))
       ;;
       
       ;; Original phases.
       (modify-phases %standard-phases
                  (replace 'build
                    (lambda _
                      (chdir "backend")
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "python"
                              "-m"
                              "build"
                              "--wheel"
                              "--no-isolation"
                              ".")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl)))))))
    (home-page "https://ofek.dev/projects/hatch/")
    (synopsis "Bootstrap binaries to build @code{python-hatch}")
    (description "Bootstrap binaries to build @code{python-hatch}")
    ;; MIT License
    (license license:expat)))
--8<---------------cut here---------------end--------------->8---

[bug#58310] Manifest for coq-mathcomp-analysis

[Garek Dyszel via Guix-patches via]

[-- Attachment #1: Type: text/plain, Size: 1355 bytes --]

Hi,

CC: ocaml team

I am including a manifest file instead of sending patches for now. It
seems like a good idea to stick with that until these packages are ready
to be put into the Guix source tree. I'm refactoring them too often.

After opening an issue on Github [1] [2], it seems that coq-elpi is the
package that is not building properly. It is clear that ocamlfind (from
ocaml-findlib) can't find coq-elpi after coq-elpi's install phase.
[1]: https://github.com/math-comp/hierarchy-builder/issues/320
[2]: https://github.com/LPCIC/coq-elpi/issues/384

It looks like the META file is not being installed by coq-elpi either.
I'm not sure whether that's relevant, since ocamlfind couldn't find
coq-elpi even when META was present (in a much older revision of this
manifest; I can dig for it but just today don't have time).

The problem seems to be something in the build process itself; if the
extra phase 'check-findlib-path' is omitted then coq-elpi's build is
reported as a success.

The later package coq-mathcomp-hierarchy-builder runs ocamlfind to find
coq-elpi, too.

What would be a way to ensure that coq-elpi is found by ocamlfind? 

Thanks!
Garek

(Manifest attached with an ocaml-elpi patch. You will need to change the path for
the ocaml-elpi (patches) field to match your directory structure, but otherwise
this manifest should work.)


[-- Attachment #2: coq-mathcomp-analysis.scm --]
[-- Type: application/octet-stream, Size: 36406 bytes --]

;; -*- mode: scheme; mode: guix-devel -*-
;;; Local Variables:
;;; sentence-end-double-space: t
;;; End:
;;; This module extends GNU Guix and is licensed under the same terms, those
;;; of the GNU GPL version 3 or (at your option) any later version.
;;;
;;; Copyright © 2022 Garek Dyszel

;; To build directly from this file, use the following command.
;; guix build --with-patch=ocaml-elpi=patches/ocaml-elpi-fix-yojson.patch -Kf coq-mathcomp-analysis.scm

(define-module (coq-mathcomp-analysis)
  #:use-module (guix)
  #:use-module (guix git-download)
  #:use-module (guix download)
  #:use-module (guix packages)
  #:use-module (guix build-system gnu)
  #:use-module (guix build gnu-build-system)
  #:use-module (guix build-system dune)
  #:use-module (guix build-system ocaml)
  #:use-module (guix build-system pyproject)
  ;; #:use-module ((guix build utils) #:prefix utils:)
  #:use-module ((guix licenses)
                #:prefix license:)
  #:use-module ((gnu packages base)
                #:prefix base:)
  #:use-module (guix build utils)
  #:use-module (guix utils)
  #:use-module (guix profiles)
  #:use-module (gnu packages)
  #:use-module (gnu packages coq)
  #:use-module (gnu packages base)
  #:use-module (gnu packages ocaml)
  #:use-module (gnu packages time)
  #:use-module (gnu packages python)
  #:use-module (gnu packages python-xyz)
  #:use-module (gnu packages python-build)
  #:use-module (gnu packages python-web)
  #:use-module (gnu packages python-crypto)
  #:use-module (gnu packages xdisorg)
  #:use-module (guix build-system python)
  #:use-module (gnu packages python-check)
  #:use-module (gnu packages check)
  #:use-module (gnu packages java)
  #:use-module (gnu packages python-compression)
  #:use-module (gnu packages lua)
  #:use-module (gnu packages version-control))

;;; Python
(define-public python-pprintpp
  ;; Git version tags are inaccurate for this package; use the
  ;; bare commit.
  (let ((commit "7ede6da1f3062bbfb32ee04353d675a5bff185e0")
        (revision "1"))
    (package
      (name "python-pprintpp")
      (version (git-version "0.3.0" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/wolever/pprintpp")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "0nk935m3ig8sc32laqbh698vwpk037yw27gd3nvwwzdv42jal2li"))))
      (inputs (list python-pypa-build python-hypothesis python-wheel
                    python-parameterized))
      (native-inputs (list python-pytest python-nose))
      (build-system pyproject-build-system)
      (arguments
       (list #:phases #~(modify-phases %standard-phases
                          (replace 'build
                            (lambda _
                              (setenv "SOURCE_DATE_EPOCH" "315532800")
                              (invoke "python"
                                      "-m"
                                      "build"
                                      "--wheel"
                                      "--no-isolation"
                                      ".")))
                          (replace 'install
                            (lambda* (#:key outputs #:allow-other-keys)
                              (let ((whl (car (find-files "dist" "\\.whl$"))))
                                (invoke "pip"
                                        "--no-cache-dir"
                                        "--no-input"
                                        "install"
                                        "--no-deps"
                                        "--prefix"
                                        #$output
                                        whl))))
                          (replace 'check
                            (lambda* (#:key tests? #:allow-other-keys)
                              (when tests?
                                (invoke "python" "test.py")))))))
      (home-page "https://github.com/wolever/pprintpp")
      (synopsis "Python pretty-printer")
      (description
       "This package is a printer for Python which pretty-prints structures.
It also attempts to print Unicode characters without escaping them.")
      (license license:bsd-3))))

(define-public python-pluggy-1.0
  (package
    (inherit python-pluggy)
    (name "python-pluggy")
    (version "1.0.0")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "pluggy" version))
              (sha256
               (base32
                "0n8iadlas2z1b4h0fc73b043c7iwfvx9rgvqm1azjmffmhxkf922"))))
    (inputs (list python-pypa-build python-wheel))
    (native-inputs (list python-pytest python-setuptools-scm))))

(define-public python-setuptools-scm-7
  (package
    (inherit python-setuptools-scm)
    (version "7.0.5")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "setuptools_scm" version))
              (sha256
               (base32
                "0i28zghzdzzkm9w8rrjwphggkfs58nh6xnqsjhmqjvqxfypi67h3"))))
    (build-system pyproject-build-system)
    (arguments
     `( ;Disabled tests to avoid extra dependencies.
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  ;; Disabled sanity check to avoid extra dependencies.
                  (delete 'sanity-check))))
    (propagated-inputs (list python-packaging-bootstrap python-tomli))))

(define-public python-pathspec-0.10.1
  (package
    (name "python-pathspec")
    (version "0.10.1")
    (source ;; (origin
     ;;   (method url-fetch)
     ;;   (uri (pypi-uri "pathspec" version))
     ;;   (sha256
     ;;    (base32
     ;;     "0g9jhhhf3zmrnvzvjjd2yhizsb6i93hmlszb09wixlr1nrhn3kks")))
     (origin
       (method git-fetch)
       (uri (git-reference
             (url
              "https://github.com/cpburnz/python-pathspec")
             (commit (string-append "v" version))))
       (sha256
        (base32 "0sgzh7ad1x098d0rln01f0qabpa7mnp26863isncbiyqsxh1gaxp"))))
    (build-system pyproject-build-system)
    (home-page "https://github.com/cpburnz/python-pathspec")
    (synopsis
     "Utility library for gitignore style pattern matching of file paths.")
    (description
     "Utility library for gitignore style pattern matching of file paths.")
    (license license:mpl2.0)))

;; This depends on packages in python-xyz.scm:
;; python-version, python-importlib-metadata, python-pathspec,
;; python-pluggy-1.0, and python-platformdirs.
(define-public python-hatchling
  (package
    (name "python-hatchling")
    (version "1.10.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/pypa/hatch")
                    (commit (string-append "hatchling-v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0ahx62w711a2vnb91ahqxrw8yi0gq0kfch3fk6akzngd13376czj"))))
    ;; python-pypa-build needed for bootstrapping.
    ;; Otherwise we get a circular reference:
    ;; python-hatchling trying to build itself, without
    ;; first having hatchling installed.
    (inputs (list python-editables
                  python-packaging-bootstrap
                  ;; Below from python-xyz.scm, can be moved to python-build.scm
                  python-pathspec-0.10.1
                  ;; Below from python-xyz.scm, can be moved to python-build.scm
                  python-pluggy-1.0
                  python-tomli))
    (build-system pyproject-build-system)
    (arguments
     `( ;Tests depend on module python-hatch, which would result in circular references
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  (replace 'build
                    (lambda _
                      (chdir "backend")
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "python"
                              "-m"
                              "build"
                              "--wheel"
                              "--no-isolation"
                              ".")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl)))))))
    (home-page "https://ofek.dev/projects/hatch/")
    (synopsis "Bootstrap binaries to build @code{python-hatch}")
    (description "Bootstrap binaries to build @code{python-hatch}")
    ;; MIT License
    (license license:expat)))

;; (define-public python-hatchling
;;     (package
;;     (name "python-hatchling")
;;     (version "1.10.0")
;;     (source (origin
;;               (method git-fetch)
;;               (uri (git-reference
;;                     (url "https://github.com/pypa/hatch")
;;                     (commit (string-append "hatchling-v" version))))
;;               (file-name (git-file-name name version))
;;               (sha256
;;                (base32
;;                 "0ahx62w711a2vnb91ahqxrw8yi0gq0kfch3fk6akzngd13376czj"))))
;;     (inputs (list python-editables
;;                   python-packaging-bootstrap
;;                   ;; Below from python-xyz.scm, can be moved to python-build.scm
;;                   python-pathspec-0.10.1
;;                   ;; Below from python-xyz.scm, can be moved to python-build.scm
;;                   python-pluggy-1.0
;;                   python-tomli
;;                   python-hatchling-bootstrap))
;;     (build-system pyproject-build-system)
;;     (arguments
;;      `( ;Tests depend on module python-hatch, which this
;;        ;; is bootstrapping.
;;        #:tests? #f
;;        #:phases (modify-phases %standard-phases
;;                   (replace 'build
;;                     (lambda _
;;                       (chdir "backend")
;;                       ;; ZIP does not support timestamps before 1980.
;;                       (setenv "SOURCE_DATE_EPOCH" "315532800")
;;                       (invoke "python"
;;                               "-m"
;;                               "build"
;;                               "--wheel"
;;                               "--no-isolation"
;;                               ".")))
;;                   (replace 'install
;;                     (lambda* (#:key outputs #:allow-other-keys)
;;                       (let ((whl (car (find-files "dist" "\\.whl$"))))
;;                         (invoke "pip"
;;                                 "--no-cache-dir"
;;                                 "--no-input"
;;                                 "install"
;;                                 "--no-deps"
;;                                 "--prefix"
;;                                 (assoc-ref %outputs "out")
;;                                 whl)))))))
;;     (home-page "https://ofek.dev/projects/hatch/")
;;     (synopsis "Bootstrap binaries to build @code{python-hatch}")
;;     (description "Bootstrap binaries to build @code{python-hatch}")
;;     ;; MIT License
;;     (license license:expat)))

(define-public python-hatch
  (package
    (name "python-hatch")
    (version "1.6.2") ;; at minimum 1.5.0
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/pypa/hatch")
                    (commit (string-append "hatch-v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0if5ssp6vlfvna1jcvap40r0f7pm45h7kbia78h5ivm17vb8p08b"
                ;;"030yi9hw50mn899pq073lw2a55r57skl2g9agjp3b4l95f3nay30"
                ))))
    (inputs (list python-pypa-build
                  python-editables
                  python-importlib-metadata
                  python-version
                  python-packaging-next
                  python-pathspec
                  python-pluggy-1.0 ;TODO: Not detected by pytest?
                  python-hatchling
                  python-tomli
                  python-platformdirs
                  python-rich
                  python-tomli-w))
    (build-system pyproject-build-system)
    (arguments
     `( ;Tests appear to be written such that the input python-pluggy-1.0 is
       ;; not detected.
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  (replace 'build
                    (lambda _
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "hatchling" "build")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl))))
                  (replace 'check
                    (lambda* (#:key tests? #:allow-other-keys)
                      (when tests?
                        (chdir "tests")
                        (invoke "pytest" "-vv"))))
                  ;; Can't have hatch as a requirement of itself.
                  (delete 'sanity-check))))
    (home-page "https://ofek.dev/projects/hatch/")
    (synopsis "Python build system with project generation")
    (description
     "Python build system with project generation.  It also defines a specific
syntax in @code{toml} files to check for dependencies.")
    ;; MIT License
    (license license:expat)))

(define-public python-hatch-vcs
  ;; Tags are not accurate; just use the commit itself.
  (let ((commit "367daedb23ba906f3e0714c64392fdd6ffa69ab2")
        (revision "1"))
    (package
      (name "python-hatch-vcs")
      (version (git-version "0.2.0" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/ofek/hatch-vcs")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "0nlnv32jqiz8ikc013h5simmiqqg0qa7pm0qcbd8yiqq1p43iw05"))))
      (build-system pyproject-build-system)
      (inputs (list python-pypa-build
                    python-pathspec-0.10.1
                    python-pluggy-1.0
                    python-editables
                    git
                    python-hatchling
                    ;; python-hatch
                    python-typing-extensions))
      (native-inputs (list python-pytest
                           ;; python-setuptools-scm-6.4 minimum
                           python-setuptools-scm-7))
      ;; (arguments
      ;;  (list #:phases #~(modify-phases %standard-phases
      ;;                     (replace 'build
      ;;                       (lambda _
      ;;                         (setenv "SOURCE_DATE_EPOCH" "315532800")
      ;;                         (invoke "python"
      ;;                                 "-m"
      ;;                                 "build"
      ;;                                 "--wheel"
      ;;                                 "--no-isolation"
      ;;                                 ".")))
      ;;                     (replace 'install
      ;;                       (lambda* (#:key outputs #:allow-other-keys)
      ;;                         (let ((whl (car (find-files "dist" "\\.whl$"))))
      ;;                           (invoke "pip"
      ;;                                   "--no-cache-dir"
      ;;                                   "--no-input"
      ;;                                   "install"
      ;;                                   "--no-deps"
      ;;                                   "--prefix"
      ;;                                   #$output
      ;;                                   whl))))
      ;;                     (replace 'check
      ;;                       (lambda* (#:key tests? #:allow-other-keys)
      ;;                         (when tests?
      ;;                           (invoke "pytest" "-vvv"))))))) ;)
      (arguments
     `( ;Tests depend on module python-hatch, which this
       ;; is bootstrapping.
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  (replace 'build
                    (lambda _
                      ;;(chdir "backend")
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "python"
                              "-m"
                              "build"
                              "--wheel"
                              "--no-isolation"
                              ".")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl)))))))
      (home-page "https://ofek.dev/projects/hatch/")
      (synopsis "Plugin for @code{python-hatch} to include versions")
      (description
       "This plugin defines a version-control syntax for use with
@code{toml} files intended for use with @code{python-hatch}.")
      ;; MIT License
      (license license:expat))))

(define-public python-pytest-icdiff
  (package
    (name "python-pytest-icdiff")
    (version "0.6")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "pytest-icdiff" version))
              (sha256
               (base32
                "1b8vzn2hvv6x25w1s446q1rfsbdik617lzpal3qb94x8a12yzwg8"))))
    (build-system pyproject-build-system)
    (propagated-inputs (list python-pypa-build python-icdiff python-pprintpp
                             python-pluggy-1.0))
    (native-inputs (list python-pytest))
    (arguments
     `(;; Tests fail with "collecting ... collected 0 items"
       #:tests? #f))
    ;; (arguments
    ;;  `(#:phases
    ;;    (modify-phases %standard-phases
    ;;      (add-before 'check 'chdir-to-test-dir
    ;;        (chdir "tests")))))
    (home-page "https://github.com/hjwp/pytest-icdiff")
    (synopsis "Colored diffs using @code{python-icdiff} for pytest output")
    (description
     "This package uses @code{python-icdiff} to add color to the output of
pytest assertions.")
    (license (license:non-copyleft "LICENSE"))))

(define-public python-hatch-fancy-pypi-readme
  (package
    (name "python-hatch-fancy-pypi-readme")
    (version "22.8.0")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "hatch_fancy_pypi_readme" version))
              (sha256
               (base32
                ;; PyPI hash problem
                ;;"1ykfz1sbz58xbjw5k9xpmn5r6ji16w8vag47j8f969bqy3w52ikx"
                "0sn2wsfbpsbf2mqhjvw62h1cfy5mz3d7iqyqvs5c20cnl0n2i4fs"))))
    (build-system pyproject-build-system)
    (propagated-inputs (list python-tomli python-typing-extensions))
    (native-inputs (list python-pypa-build
                         python-pathspec-0.10.1
                         python-pluggy-1.0
                         python-editables
                         python-hatchling
                         python-wheel
                         python-pytest
                         python-pytest-icdiff))
    (arguments
     `(#:phases (modify-phases %standard-phases
                  (add-before 'build 'disable-broken-tests
                    (lambda _
                      ;; Skip the tests for "building". Guix already does this,
                      ;; so we don't need to test it for this package.
                      (chdir "tests")
                      (invoke "sed" "-i"
                              "11ipytest.skip('No need to test\
 building; guix does this already', allow_module_level=True)"
                              "test_end_to_end.py")
                      (chdir "../")))
                  ;; XXX: PEP 517 manual build/install procedures copied from
                  ;; python-isort.
                  (replace 'build
                    (lambda _
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "python"
                              "-m"
                              "build"
                              "--wheel"
                              "--no-isolation"
                              ".")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl))))
                  (replace 'check
                    (lambda* (#:key tests? #:allow-other-keys)
                      (when tests?
                        (invoke "pytest" "-vv")))))))
    (home-page
     "https://github.com/hynek/hatch-fancy-pypi-readme")
    (synopsis "Syntax for styling PyPI READMEs")
    (description
     "Defines a syntax for the python-hatch build system, intended for styling
READMEs for PyPI.")
    ;; MIT License
    (license license:expat)))

;; Has to be done manually. DO NOT copy and paste this one.
(define-public python-jsonschema-4.15
  (package
    (inherit python-jsonschema-next)
    (version "4.16.0")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "jsonschema" version))
              (sha256
               (base32
                ;; PyPI hashing problem
                "08sbw5fn19vn8x7c216gkczyzd575702yx2vmqdrgxpgfvq5jl0n"
                ;;"07pyh8g4csapkfjgjww7vkxwvh1qwxwqxz82wm2b1kmxj69rgx11"
                ))))
    (native-inputs (list python-pypa-build
                         python-twisted
                         python-hatch
                         python-hatchling
                         python-pathspec-0.10.1
                         python-pluggy-1.0
                         python-editables
                         python-hatch-vcs
                         python-setuptools-scm-7
                         python-hatch-fancy-pypi-readme))
    (propagated-inputs (list python-attrs
                             python-importlib-metadata
                             python-pyrsistent
                             python-typing-extensions
                             python-hatch-vcs))
    (home-page "https://github.com/python-jsonschema/jsonschema")))

;;; OCaml
;; Requires python-jsonschema with version at minimum 4.6.0 to run
;; tests. 
;; See https://github.com/ahrefs/atd/issues/306 for more info on that.
(define-public ocaml-atd
  (package
    (name "ocaml-atd")
    (version "2.10.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/ahrefs/atd")
                    (commit version)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "10fgahdigrl01py0k0q2d6a60yps38q96dxhjnzm9jz4g931716l"))))
    (build-system dune-build-system)
    (arguments
     `(#:phases (modify-phases %standard-phases
                  (replace 'check
                    (lambda* (#:key tests? #:allow-other-keys)
                      ;; The dune-build-system does not run "make test" but
                      ;; "dune runtest test --release".
                      ;; This project, rather, needs us to run "make test".
                      ;;
                      ;; For this package (ocaml-atd), we DO NOT run all the
                      ;; tests. The atd repository has resources for several
                      ;; different interfaces (python, scala, etc), but we
                      ;; don't need to run those tests if we are just
                      ;; interested in the ocaml interface.
                      ;; So we stick with just the ocaml tests here.
                      (when tests?
                        (invoke "make" "test-ocaml")))))))
    (propagated-inputs (list ocaml-menhir
                             ocaml-easy-format
                             ocaml-odoc
                             ocaml-re
                             ocaml-camlp-streams
                             ocaml-biniou
                             ocaml-yojson
                             ocaml-cmdliner))
    (native-inputs (list ocaml-alcotest
                         python-pypa-build
                         python-jsonschema-4.15
                         python-flake8
                         python-mypy
                         python-pytest))
    (inputs (list python))
    (home-page "https://github.com/ahrefs/atd")
    (synopsis "Parser for the ATD data format description language")
    (description
     "ATD is an OCaml library providing a parser for the Adjustable Type
Definitions language.")
    ;; Modified BSD license
    (license (license:non-copyleft "LICENSE.md"))))

(define-public ocaml-elpi
  (package
    (name "ocaml-elpi")
    ;; For more information on which version works with Coq 8.16,
    ;; see the relevant issue:
    ;; https://github.com/math-comp/hierarchy-builder/issues/297
    ;; Here we use
    ;; coq-elpi 1.15.4 + ocaml-elpi 1.16.5 +
    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.16).
    ;; (version "1.15.2")
    ;;(version "1.16.5")
    (version "1.16.7")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/LPCIC/elpi")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                ;; for 1.16.5
                ;;"1l6grpglkvyyj0p01l0q5ih12lp4vizamgj7i63ig82gqpyzk9dl"
                ;; for the version that the patch is based on (1.16.7)
                "1i0731f7jj48zvkla959pffj5l0qynmfyxljgszc6z3b4lpni1xc"))
              ;; Fix incompatibility with ocaml-yojson@2.0.2.
              ;; See <https://github.com/LPCIC/elpi/pull/167>.
              ;;(patches (search-patches "ocaml-elpi-fix-yojson.patch"))
              (patches '("/home/chips/home/code/guix_packages/built/patches/ocaml-elpi-fix-yojson.patch"))
              ))
    (build-system dune-build-system)
    (arguments
     `(#:test-target "tests"))
     ;; Build currently fails with error (repeated several times):
     ;; 'Warning 6 [labels-omitted: label argsdepth was omitted in the
    ;; application of this function.'
    (propagated-inputs (list ocaml-stdlib-shims
                             ocaml-ppxlib
                             ocaml-menhir
                             ocaml-re
                             ocaml-ppx-deriving
                             ocaml-atd
                             ocaml-camlp-streams
                             ocaml-biniou
                             ocaml-yojson))
    (native-inputs (list ocaml-ansiterminal ocaml-cmdliner time))
    (home-page "https://github.com/LPCIC/elpi")
    (synopsis "ELPI - Embeddable λProlog Interpreter")
    (description
     "ELPI is an extension language for OCaml.  It implements a variant of
λProlog enriched with Constraint Handling Rules, a programming language for
manipulating syntax trees with binders.

This package provides both a command line interpreter, elpi, and an OCaml
library with the same name.")
    (license license:lgpl2.1+)))

;;; Coq
(define-public coq-elpi
  (package
    (name "coq-elpi")
    (version "1.16.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/LPCIC/coq-elpi")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "18w899fcz4kzx7zyr7a0g4avclbm5f82g7kh76b9fy2s99jz6q5c"))))
    ;;(build-system gnu-build-system)
    (build-system ocaml-build-system)
    (propagated-inputs (list coq-core))
    (inputs (list python lua-5.1 ocaml ocaml-elpi ocaml-zarith coq-core
                  coq-stdlib ocaml-findlib)) 
    (arguments
     `(#:test-target "test"
       ;; From the repo: "COQBIN=%{bin}%/" "ELPIDIR=%{prefix}%/lib/elpi" "OCAMLWARN="
       #:make-flags ,#~(list (string-append "COQBIN="
                                            #$(this-package-input "coq-core")
                                            "/bin/")
                             (string-append "ELPIDIR="
                                            #$(this-package-input "ocaml-elpi")
                                            "/lib/ocaml/site-lib/elpi")
                             "OCAMLWARN=")
       #:phases (modify-phases %standard-phases
                  (delete 'configure)
                  (add-after 'check 'check-findlib-path
                    (lambda _
                      (invoke "ocamlfind" "query" "coq-elpi"))))))
    (home-page "https://github.com/LPCIC/coq-elpi")
    (synopsis "Elpi extension language for Coq")
    (description
     "Coq-elpi provides a Coq plugin that embeds ELPI, an extension language
for OCaml that is an implementation of λProlog.  It also provides a way to
embed Coq's terms into λProlog using the Higher-Order Abstract Syntax approach
and a way to read terms back.  In addition to that it exports to ELPI a set of
Coq's primitives.  Finally it provides a way to define new vernacular commands
and new tactics.")
    (license license:lgpl2.1)))

(define-public coq-mathcomp-hierarchy-builder
  (package
    (name "coq-mathcomp-hierarchy-builder")
    ;; For more information on which version works with Coq 8.16,
    ;; see the relevant issue:
    ;; https://github.com/math-comp/hierarchy-builder/issues/297
    ;; Here we use
    ;; coq-elpi 1.15.4 + ocaml-elpi 1.16.5 +
    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.16)
    ;;(version "1.3.0")
    (version "1.4.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/math-comp/hierarchy-builder")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                ;; 1.3.0
                ;;"17k7rlxdx43qda6i1yafpgc64na8br285cb0mbxy5wryafcdrkrc"
                ;; 1.4.0
                "1g7narbx5n8bbnnnn8kmgk62clah9fsy9jb154xcr41p8psrvrxl"))))
    ;;(build-system ocaml-build-system) ;; fails for same reason as dune.
    (build-system gnu-build-system)
    (arguments
     `(#:make-flags ,#~(list ;; (string-append "COQBIN="
                             ;;                #$(this-package-input "coq-core")
                             ;;                "/bin/")
                             (string-append "ELPIDIR="
                                            #$(this-package-input "coq-elpi")
                                            "/lib/coq/user-contrib/elpi/")
                             (string-append "COQLIBINSTALL="
                                            (assoc-ref %outputs "out")
                                            "/lib/coq/user-contrib"))
       #:test-target "test-suite"
       #:phases (modify-phases %standard-phases
                  (delete 'configure)
                  (add-after 'build 'fail-fast
                    (lambda _
                      (invoke "stuff")))
                  )))
    (inputs (list coq-core
                  coq-stdlib
                  ;; coq-mathcomp
                  which
                  ocaml
                  coq-elpi
                  ;;ocaml-elpi
                  ))
    (synopsis "Hierarchy structures for the Coq proof assistant")
    (description
     "Hierarchy Builder (HB) provides high level commands to declare a
hierarchy of interfaces for the Coq system.

Given a structure one can develop its theory, and that theory becomes
applicable to all examples of the structure.  One can also declare alternative
interfaces, for convenience or backward compatibility, and provide glue code
linking these interfaces to the structures part of the hierarchy.")
    (home-page "https://math-comp.github.io/")
    ;; MIT license
    (license license:expat)))

(define-public coq-mathcomp-analysis
  (package
    (name "coq-mathcomp-analysis")
    (version "0.5.4")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/math-comp/analysis")
                    (commit version)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1l1yaxbmqr4li8x7g51q98a6v383dnf94lw1b74ccpwqz9qybz9m"))))
    (build-system gnu-build-system)
    (arguments
     `( ;No rule to make target 'check'. Stop.
       ;; Makefile.common has no references to tests.
       ;; There are also no references to tests found after
       ;; running the following commands in the top
       ;; directory of the cloned repo:
       ;; find -type d | grep -i test
       ;; rg test # where rg is ripgrep
       ;; Checking the git log, we find: "Add test suite for
       ;; joins and several fixes".
       ;;
       ;; If tests are included, this quote suggests that they
       ;; would be part of the source files themselves,
       ;; and the tests would be run as part of the build
       ;; process.
       #:tests? #f
       #:make-flags ,#~(list (string-append "COQBIN="
                                            #$(this-package-input "coq-core")
                                            "/bin/")
                             (string-append "COQBININSTALL="
                                            (assoc-ref %outputs "out") "/bin/")
                             (string-append "DESTDIR="
                                            (assoc-ref %outputs "out"))
                             (string-append "COQMF_COQLIB="
                                            (assoc-ref %outputs "out")
                                            "/lib/ocaml/site-lib/coq")
                             (string-append "COQLIBINSTALL="
                                            (assoc-ref %outputs "out")
                                            "/lib/coq/user-contrib"))
       #:phases (modify-phases %standard-phases
                  (delete 'configure)
                  (replace 'build
                    (lambda* (#:key make-flags #:allow-other-keys)
                      (apply invoke "make" "build" make-flags))))))
    (inputs (list coq
                  coq-stdlib
                  coq-mathcomp
                  coq-mathcomp-finmap
                  coq-mathcomp-hierarchy-builder
                  coq-elpi
                  coq-mathcomp-bigenough
                  coq-core
                  which))
    (synopsis "Real analysis for the Coq proof assistant")
    (description
     "This repository contains an experimental library for real analysis for
the Coq proof-assistant, using the Mathematical Components library.")
    (home-page "https://math-comp.github.io/")
    (license license:cecill-c)))

coq-elpi

[-- Attachment #3: ocaml-elpi-fix-yojson.patch --]
[-- Type: text/x-patch, Size: 12410431 bytes --]

From 998dc654e5acd66d5d0c8ebe79ed04dd424eb698 Mon Sep 17 00:00:00 2001
From: Julien Puydt <julien.puydt@gmail.com>
Date: Mon, 24 Oct 2022 11:44:08 +0200
Subject: [PATCH 1/2] Fix for yojson 2.0.2

---
 src/elpi_trace_elaborator.ml          |     6 +-
 tests/sources/broken_trace1.elab.json | 35691 ++++++++----------------
 tests/sources/trace.elab.json         |     3 +-
 tests/sources/trace2.elab.json        |    27 +-
 tests/sources/trace_chr.elab.json     |    90 +-
 tests/sources/trace_findall.elab.json |    12 +-
 6 files changed, 11944 insertions(+), 23885 deletions(-)

diff --git a/src/elpi_trace_elaborator.ml b/src/elpi_trace_elaborator.ml
index 6d3ac0e2..6c07209c 100644
--- a/src/elpi_trace_elaborator.ml
+++ b/src/elpi_trace_elaborator.ml
@@ -664,6 +664,6 @@ let main =
 
   let cards = Trace.cards steps ~stack_frames ~aggregated_goal_success ~goal_text ~goal_attempts in
 
-  let ob = Bi_outbuf.create_channel_writer stdout in
-  write_trace ob cards;
-  Bi_outbuf.flush_channel_writer ob
+  let buf = Buffer.create 1000 in
+  write_trace buf cards;
+  Buffer.output_buffer stdout buf
diff --git a/tests/sources/broken_trace1.elab.json b/tests/sources/broken_trace1.elab.json
index ed59855d..0daa61ab 100644
--- a/tests/sources/broken_trace1.elab.json
+++ b/tests/sources/broken_trace1.elab.json
@@ -5,8 +5,7 @@
     "step": [
       "Init",
       {
-        "goal_text":
-          "attributes\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] =>\n main\n  [const-decl _ \n    (some\n      (app\n        [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n         global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
+        "goal_text": "attributes\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] =>\n main\n  [const-decl _ \n    (some\n      (app\n        [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n         global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
         "goal_id": 1121
       }
     ],
@@ -19,8 +18,7 @@
       "Inference",
       {
         "current_goal_id": 1121,
-        "current_goal_text":
-          "attributes\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] =>\n main\n  [const-decl _ \n    (some\n      (app\n        [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n         global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
+        "current_goal_text": "attributes\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] =>\n main\n  [const-decl _ \n    (some\n      (app\n        [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n         global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -31,8 +29,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "main\n [const-decl _ \n   (some\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
+                "goal_text": "main\n [const-decl _ \n   (some\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
                 "goal_id": 1122
               }
             ],
@@ -58,8 +55,7 @@
       "Inference",
       {
         "current_goal_id": 1122,
-        "current_goal_text":
-          "main\n [const-decl _ \n   (some\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
+        "current_goal_text": "main\n [const-decl _ \n   (some\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
         "current_goal_predicate": "main",
         "failed_attempts": [],
         "successful_attempts": [
@@ -68,8 +64,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                  "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                   "rule_loc": [
                     "File",
                     {
@@ -93,8 +88,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1123 },
               {
-                "goal_text":
-                  "with-attributes\n (with-logging\n   (instance.declare-const _ \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _))",
+                "goal_text": "with-attributes\n (with-logging\n   (instance.declare-const _ \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _))",
                 "goal_id": 1124
               }
             ],
@@ -107,8 +101,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -143,13 +136,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "main\n [const-decl _ \n   (some\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
+              "goal_text": "main\n [const-decl _ \n   (some\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
               "goal_id": 1122
             },
             "cut_branch": {
-              "rule_text":
-                "(main [A0, A1]) :- (!), \n (coq.warning HB HB.deprecated \n   The syntax \"HB.instance Key FactoryInstance\" is deprecated, use \"HB.instance Definition\" instead), \n (with-attributes (with-logging (instance.declare-existing A0 A1))).",
+              "rule_text": "(main [A0, A1]) :- (!), \n (coq.warning HB HB.deprecated \n   The syntax \"HB.instance Key FactoryInstance\" is deprecated, use \"HB.instance Definition\" instead), \n (with-attributes (with-logging (instance.declare-existing A0 A1))).",
               "rule_loc": [
                 "File",
                 {
@@ -163,13 +154,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "main\n [const-decl _ \n   (some\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
+              "goal_text": "main\n [const-decl _ \n   (some\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0])) (arity X1)]",
               "goal_id": 1122
             },
             "cut_branch": {
-              "rule_text":
-                "(main _) :- (coq.error\n              Usage: HB.instance Definition <Name> := <Builder> T ...).",
+              "rule_text": "(main _) :- (coq.error\n              Usage: HB.instance Definition <Name> := <Builder> T ...).",
               "rule_loc": [
                 "File",
                 {
@@ -193,8 +182,7 @@
       "Inference",
       {
         "current_goal_id": 1124,
-        "current_goal_text":
-          "with-attributes\n (with-logging\n   (instance.declare-const _ \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _))",
+        "current_goal_text": "with-attributes\n (with-logging\n   (instance.declare-const _ \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _))",
         "current_goal_predicate": "with-attributes",
         "failed_attempts": [],
         "successful_attempts": [
@@ -203,13 +191,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                  "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 14,
                       "column": 0,
                       "character": 453
@@ -227,14 +213,12 @@
             "siblings": [
               { "goal_text": "attributes X2", "goal_id": 1125 },
               {
-                "goal_text":
-                  "pi c0 \\\n pi c1 \\\n  pi c2 \\\n   pi c3 \\\n    pi c4 \\\n     pi c5 \\\n      pi c6 \\\n       pi c7 \\\n        parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n         , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n          (supported-attribute (att c7 attmap)) (!) \n          (parse-attributes.aux c2 c3 c5) \n          (pi c8 \\ supported-attribute (att c8 string) :- ! =>\n            parse-attributes.aux c1  c6) \n          (std.append c5 [get-option c7 c6] c4) =>\n coq.parse-attributes X2 \n  [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n   att short.type string, att short.pack string, att infer attmap, \n   att key string, att arg_sort bool, att log bool, att log.raw bool, \n   att compress_coercions bool, att export bool, att skip string, \n   att local bool, att fail bool, att doc string, att primitive_class bool, \n   att primitive bool, att non_forgetful_inheritance bool, att hnf bool] X3",
+                "goal_text": "pi c0 \\\n pi c1 \\\n  pi c2 \\\n   pi c3 \\\n    pi c4 \\\n     pi c5 \\\n      pi c6 \\\n       pi c7 \\\n        parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n         , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n          (supported-attribute (att c7 attmap)) (!) \n          (parse-attributes.aux c2 c3 c5) \n          (pi c8 \\ supported-attribute (att c8 string) :- ! =>\n            parse-attributes.aux c1  c6) \n          (std.append c5 [get-option c7 c6] c4) =>\n coq.parse-attributes X2 \n  [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n   att short.type string, att short.pack string, att infer attmap, \n   att key string, att arg_sort bool, att log bool, att log.raw bool, \n   att compress_coercions bool, att export bool, att skip string, \n   att local bool, att fail bool, att doc string, att primitive_class bool, \n   att primitive bool, att non_forgetful_inheritance bool, att hnf bool] X3",
                 "goal_id": 1126
               },
               { "goal_text": "!", "goal_id": 1127 },
               {
-                "goal_text":
-                  "X3 =>\n (save-docstring ,\n   with-logging\n    (instance.declare-const _ \n      (app\n        [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n         global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _))",
+                "goal_text": "X3 =>\n (save-docstring ,\n   with-logging\n    (instance.declare-const _ \n      (app\n        [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n         global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _))",
                 "goal_id": 1128
               }
             ],
@@ -247,13 +231,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -268,8 +250,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -310,8 +291,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(attributes\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]) :- .",
+                  "rule_text": "(attributes\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]) :- .",
                   "rule_loc": [ "Context", 1 ]
                 }
               ],
@@ -332,8 +312,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(attributes\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]) :- .",
+                "rule_text": "(attributes\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]) :- .",
                 "rule_loc": [ "Context", 1 ]
               }
             ],
@@ -344,13 +323,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -365,8 +342,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -398,8 +374,7 @@
       "Inference",
       {
         "current_goal_id": 1126,
-        "current_goal_text":
-          "pi c0 \\\n pi c1 \\\n  pi c2 \\\n   pi c3 \\\n    pi c4 \\\n     pi c5 \\\n      pi c6 \\\n       pi c7 \\\n        parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n         , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n          (supported-attribute (att c7 attmap)) (!) \n          (parse-attributes.aux c2 c3 c5) \n          (pi c8 \\ supported-attribute (att c8 string) :- ! =>\n            parse-attributes.aux c1  c6) \n          (std.append c5 [get-option c7 c6] c4) =>\n coq.parse-attributes\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] \n  [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n   att short.type string, att short.pack string, att infer attmap, \n   att key string, att arg_sort bool, att log bool, att log.raw bool, \n   att compress_coercions bool, att export bool, att skip string, \n   att local bool, att fail bool, att doc string, att primitive_class bool, \n   att primitive bool, att non_forgetful_inheritance bool, att hnf bool] X3",
+        "current_goal_text": "pi c0 \\\n pi c1 \\\n  pi c2 \\\n   pi c3 \\\n    pi c4 \\\n     pi c5 \\\n      pi c6 \\\n       pi c7 \\\n        parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n         , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n          (supported-attribute (att c7 attmap)) (!) \n          (parse-attributes.aux c2 c3 c5) \n          (pi c8 \\ supported-attribute (att c8 string) :- ! =>\n            parse-attributes.aux c1  c6) \n          (std.append c5 [get-option c7 c6] c4) =>\n coq.parse-attributes\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] \n  [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n   att short.type string, att short.pack string, att infer attmap, \n   att key string, att arg_sort bool, att log bool, att log.raw bool, \n   att compress_coercions bool, att export bool, att skip string, \n   att local bool, att fail bool, att doc string, att primitive_class bool, \n   att primitive bool, att non_forgetful_inheritance bool, att hnf bool] X3",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -410,8 +385,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.parse-attributes\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] \n [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] X3",
+                "goal_text": "coq.parse-attributes\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] \n [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] X3",
                 "goal_id": 1129
               }
             ],
@@ -429,13 +403,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -450,8 +422,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -483,8 +454,7 @@
       "Inference",
       {
         "current_goal_id": 1129,
-        "current_goal_text":
-          "coq.parse-attributes\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] \n [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] X3",
+        "current_goal_text": "coq.parse-attributes\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)] \n [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] X3",
         "current_goal_predicate": "coq.parse-attributes",
         "failed_attempts": [],
         "successful_attempts": [
@@ -493,8 +463,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                  "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -520,13 +489,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.map\n [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X4",
+                "goal_text": "std.map\n [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X4",
                 "goal_id": 1130
               },
               {
-                "goal_text":
-                  "X4 =>\n parse-attributes.aux\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
+                "goal_text": "X4 =>\n parse-attributes.aux\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
                 "goal_id": 1131
               },
               { "goal_text": "!", "goal_id": 1132 }
@@ -540,8 +507,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -565,13 +531,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -586,8 +550,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -619,8 +582,7 @@
       "Inference",
       {
         "current_goal_id": 1130,
-        "current_goal_text":
-          "std.map\n [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X4",
+        "current_goal_text": "std.map\n [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X4",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -629,8 +591,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -660,8 +621,7 @@
                 "goal_id": 1133
               },
               {
-                "goal_text":
-                  "std.map\n [att mathcomp bool, att mathcomp.axiom string, att short.type string, \n  att short.pack string, att infer attmap, att key string, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X6",
+                "goal_text": "std.map\n [att mathcomp bool, att mathcomp.axiom string, att short.type string, \n  att short.pack string, att infer attmap, att key string, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X6",
                 "goal_id": 1134
               }
             ],
@@ -674,8 +634,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -694,8 +653,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -719,13 +677,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -740,8 +696,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -799,8 +754,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -819,8 +773,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -844,13 +797,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -865,8 +816,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -898,8 +848,7 @@
       "Inference",
       {
         "current_goal_id": 1134,
-        "current_goal_text":
-          "std.map\n [att mathcomp bool, att mathcomp.axiom string, att short.type string, \n  att short.pack string, att infer attmap, att key string, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X6",
+        "current_goal_text": "std.map\n [att mathcomp bool, att mathcomp.axiom string, att short.type string, \n  att short.pack string, att infer attmap, att key string, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X6",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -908,8 +857,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -939,8 +887,7 @@
                 "goal_id": 1135
               },
               {
-                "goal_text":
-                  "std.map\n [att mathcomp.axiom string, att short.type string, att short.pack string, \n  att infer attmap, att key string, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X8",
+                "goal_text": "std.map\n [att mathcomp.axiom string, att short.type string, att short.pack string, \n  att infer attmap, att key string, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X8",
                 "goal_id": 1136
               }
             ],
@@ -953,8 +900,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -973,8 +919,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -993,8 +938,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -1018,13 +962,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -1039,8 +981,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -1098,8 +1039,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1118,8 +1058,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1138,8 +1077,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -1163,13 +1101,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -1184,8 +1120,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -1217,8 +1152,7 @@
       "Inference",
       {
         "current_goal_id": 1136,
-        "current_goal_text":
-          "std.map\n [att mathcomp.axiom string, att short.type string, att short.pack string, \n  att infer attmap, att key string, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X8",
+        "current_goal_text": "std.map\n [att mathcomp.axiom string, att short.type string, att short.pack string, \n  att infer attmap, att key string, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X8",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -1227,8 +1161,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -1254,13 +1187,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X9 = supported-attribute (att mathcomp.axiom string)",
+                "goal_text": "X9 = supported-attribute (att mathcomp.axiom string)",
                 "goal_id": 1137
               },
               {
-                "goal_text":
-                  "std.map\n [att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X10",
+                "goal_text": "std.map\n [att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X10",
                 "goal_id": 1138
               }
             ],
@@ -1273,8 +1204,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1293,8 +1223,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1313,8 +1242,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1333,8 +1261,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -1358,13 +1285,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -1379,8 +1304,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -1412,8 +1336,7 @@
       "Inference",
       {
         "current_goal_id": 1137,
-        "current_goal_text":
-          "X9 = supported-attribute (att mathcomp.axiom string)",
+        "current_goal_text": "X9 = supported-attribute (att mathcomp.axiom string)",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -1442,8 +1365,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1462,8 +1384,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1482,8 +1403,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1502,8 +1422,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -1527,13 +1446,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -1548,8 +1465,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -1581,8 +1497,7 @@
       "Inference",
       {
         "current_goal_id": 1138,
-        "current_goal_text":
-          "std.map\n [att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X10",
+        "current_goal_text": "std.map\n [att short.type string, att short.pack string, att infer attmap, \n  att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X10",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -1591,8 +1506,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -1618,13 +1532,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X11 = supported-attribute (att short.type string)",
+                "goal_text": "X11 = supported-attribute (att short.type string)",
                 "goal_id": 1139
               },
               {
-                "goal_text":
-                  "std.map\n [att short.pack string, att infer attmap, att key string, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X12",
+                "goal_text": "std.map\n [att short.pack string, att infer attmap, att key string, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X12",
                 "goal_id": 1140
               }
             ],
@@ -1637,8 +1549,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1657,8 +1568,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1677,8 +1587,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1697,8 +1606,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1717,8 +1625,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -1742,13 +1649,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -1763,8 +1668,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -1796,8 +1700,7 @@
       "Inference",
       {
         "current_goal_id": 1139,
-        "current_goal_text":
-          "X11 = supported-attribute (att short.type string)",
+        "current_goal_text": "X11 = supported-attribute (att short.type string)",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -1826,8 +1729,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1846,8 +1748,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1866,8 +1767,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1886,8 +1786,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -1906,8 +1805,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -1931,13 +1829,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -1952,8 +1848,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -1985,8 +1880,7 @@
       "Inference",
       {
         "current_goal_id": 1140,
-        "current_goal_text":
-          "std.map\n [att short.pack string, att infer attmap, att key string, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X12",
+        "current_goal_text": "std.map\n [att short.pack string, att infer attmap, att key string, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X12",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -1995,8 +1889,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -2022,13 +1915,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X13 = supported-attribute (att short.pack string)",
+                "goal_text": "X13 = supported-attribute (att short.pack string)",
                 "goal_id": 1141
               },
               {
-                "goal_text":
-                  "std.map\n [att infer attmap, att key string, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X14",
+                "goal_text": "std.map\n [att infer attmap, att key string, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X14",
                 "goal_id": 1142
               }
             ],
@@ -2041,8 +1932,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2061,8 +1951,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2081,8 +1970,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2101,8 +1989,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2121,8 +2008,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2141,8 +2027,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -2166,13 +2051,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -2187,8 +2070,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -2220,8 +2102,7 @@
       "Inference",
       {
         "current_goal_id": 1141,
-        "current_goal_text":
-          "X13 = supported-attribute (att short.pack string)",
+        "current_goal_text": "X13 = supported-attribute (att short.pack string)",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -2250,8 +2131,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2270,8 +2150,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2290,8 +2169,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2310,8 +2188,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2330,8 +2207,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2350,8 +2226,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -2375,13 +2250,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -2396,8 +2269,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -2429,8 +2301,7 @@
       "Inference",
       {
         "current_goal_id": 1142,
-        "current_goal_text":
-          "std.map\n [att infer attmap, att key string, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X14",
+        "current_goal_text": "std.map\n [att infer attmap, att key string, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X14",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -2439,8 +2310,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -2470,8 +2340,7 @@
                 "goal_id": 1143
               },
               {
-                "goal_text":
-                  "std.map\n [att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X16",
+                "goal_text": "std.map\n [att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X16",
                 "goal_id": 1144
               }
             ],
@@ -2484,8 +2353,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2504,8 +2372,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2524,8 +2391,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2544,8 +2410,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2564,8 +2429,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2584,8 +2448,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2604,8 +2467,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -2629,13 +2491,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -2650,8 +2510,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -2709,8 +2568,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2729,8 +2587,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2749,8 +2606,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2769,8 +2625,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2789,8 +2644,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2809,8 +2663,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2829,8 +2682,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -2854,13 +2706,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -2875,8 +2725,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -2908,8 +2757,7 @@
       "Inference",
       {
         "current_goal_id": 1144,
-        "current_goal_text":
-          "std.map\n [att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X16",
+        "current_goal_text": "std.map\n [att key string, att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X16",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -2918,8 +2766,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -2949,8 +2796,7 @@
                 "goal_id": 1145
               },
               {
-                "goal_text":
-                  "std.map\n [att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X18",
+                "goal_text": "std.map\n [att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X18",
                 "goal_id": 1146
               }
             ],
@@ -2963,8 +2809,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -2983,8 +2828,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3003,8 +2847,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3023,8 +2866,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3043,8 +2885,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3063,8 +2904,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3083,8 +2923,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3103,8 +2942,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -3128,13 +2966,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -3149,8 +2985,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -3208,8 +3043,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3228,8 +3062,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3248,8 +3081,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3268,8 +3100,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3288,8 +3119,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3308,8 +3138,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3328,8 +3157,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3348,8 +3176,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -3373,13 +3200,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -3394,8 +3219,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -3427,8 +3251,7 @@
       "Inference",
       {
         "current_goal_id": 1146,
-        "current_goal_text":
-          "std.map\n [att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X18",
+        "current_goal_text": "std.map\n [att arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X18",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -3437,8 +3260,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -3468,8 +3290,7 @@
                 "goal_id": 1147
               },
               {
-                "goal_text":
-                  "std.map\n [att log bool, att log.raw bool, att compress_coercions bool, \n  att export bool, att skip string, att local bool, att fail bool, \n  att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X20",
+                "goal_text": "std.map\n [att log bool, att log.raw bool, att compress_coercions bool, \n  att export bool, att skip string, att local bool, att fail bool, \n  att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X20",
                 "goal_id": 1148
               }
             ],
@@ -3482,8 +3303,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3502,8 +3322,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3522,8 +3341,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3542,8 +3360,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3562,8 +3379,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3582,8 +3398,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3602,8 +3417,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3622,8 +3436,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3642,8 +3455,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -3667,13 +3479,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -3688,8 +3498,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -3749,8 +3558,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3769,8 +3577,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3789,8 +3596,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3809,8 +3615,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3829,8 +3634,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3849,8 +3653,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3869,8 +3672,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3889,8 +3691,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -3909,8 +3710,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -3934,13 +3734,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -3955,8 +3753,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -3988,8 +3785,7 @@
       "Inference",
       {
         "current_goal_id": 1148,
-        "current_goal_text":
-          "std.map\n [att log bool, att log.raw bool, att compress_coercions bool, \n  att export bool, att skip string, att local bool, att fail bool, \n  att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X20",
+        "current_goal_text": "std.map\n [att log bool, att log.raw bool, att compress_coercions bool, \n  att export bool, att skip string, att local bool, att fail bool, \n  att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X20",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -3998,8 +3794,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -4029,8 +3824,7 @@
                 "goal_id": 1149
               },
               {
-                "goal_text":
-                  "std.map\n [att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X22",
+                "goal_text": "std.map\n [att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X22",
                 "goal_id": 1150
               }
             ],
@@ -4043,8 +3837,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4063,8 +3856,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4083,8 +3875,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4103,8 +3894,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4123,8 +3913,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4143,8 +3932,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4163,8 +3951,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4183,8 +3970,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4203,8 +3989,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4223,8 +4008,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -4248,13 +4032,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -4269,8 +4051,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -4328,8 +4109,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4348,8 +4128,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4368,8 +4147,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4388,8 +4166,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4408,8 +4185,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4428,8 +4204,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4448,8 +4223,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4468,8 +4242,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4488,8 +4261,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4508,8 +4280,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -4533,13 +4304,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -4554,8 +4323,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -4587,8 +4355,7 @@
       "Inference",
       {
         "current_goal_id": 1150,
-        "current_goal_text":
-          "std.map\n [att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X22",
+        "current_goal_text": "std.map\n [att log.raw bool, att compress_coercions bool, att export bool, \n  att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X22",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -4597,8 +4364,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -4628,8 +4394,7 @@
                 "goal_id": 1151
               },
               {
-                "goal_text":
-                  "std.map\n [att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X24",
+                "goal_text": "std.map\n [att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X24",
                 "goal_id": 1152
               }
             ],
@@ -4642,8 +4407,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4662,8 +4426,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4682,8 +4445,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4702,8 +4464,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4722,8 +4483,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4742,8 +4502,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4762,8 +4521,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4782,8 +4540,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4802,8 +4559,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4822,8 +4578,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4842,8 +4597,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -4867,13 +4621,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -4888,8 +4640,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -4947,8 +4698,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4967,8 +4717,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -4987,8 +4736,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5007,8 +4755,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5027,8 +4774,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5047,8 +4793,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5067,8 +4812,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5087,8 +4831,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5107,8 +4850,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5127,8 +4869,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5147,8 +4888,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -5172,13 +4912,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -5193,8 +4931,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -5226,8 +4963,7 @@
       "Inference",
       {
         "current_goal_id": 1152,
-        "current_goal_text":
-          "std.map\n [att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X24",
+        "current_goal_text": "std.map\n [att compress_coercions bool, att export bool, att skip string, \n  att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X24",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -5236,8 +4972,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -5263,13 +4998,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X25 = supported-attribute (att compress_coercions bool)",
+                "goal_text": "X25 = supported-attribute (att compress_coercions bool)",
                 "goal_id": 1153
               },
               {
-                "goal_text":
-                  "std.map\n [att export bool, att skip string, att local bool, att fail bool, \n  att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X26",
+                "goal_text": "std.map\n [att export bool, att skip string, att local bool, att fail bool, \n  att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X26",
                 "goal_id": 1154
               }
             ],
@@ -5282,8 +5015,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5302,8 +5034,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5322,8 +5053,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5342,8 +5072,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5362,8 +5091,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5382,8 +5110,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5402,8 +5129,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5422,8 +5148,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5442,8 +5167,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5462,8 +5186,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5482,8 +5205,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5502,8 +5224,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -5527,13 +5248,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -5548,8 +5267,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -5581,8 +5299,7 @@
       "Inference",
       {
         "current_goal_id": 1153,
-        "current_goal_text":
-          "X25 = supported-attribute (att compress_coercions bool)",
+        "current_goal_text": "X25 = supported-attribute (att compress_coercions bool)",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -5611,8 +5328,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5631,8 +5347,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5651,8 +5366,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5671,8 +5385,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5691,8 +5404,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5711,8 +5423,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5731,8 +5442,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5751,8 +5461,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5771,8 +5480,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5791,8 +5499,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5811,8 +5518,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5831,8 +5537,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -5856,13 +5561,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -5877,8 +5580,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -5910,8 +5612,7 @@
       "Inference",
       {
         "current_goal_id": 1154,
-        "current_goal_text":
-          "std.map\n [att export bool, att skip string, att local bool, att fail bool, \n  att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X26",
+        "current_goal_text": "std.map\n [att export bool, att skip string, att local bool, att fail bool, \n  att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X26",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -5920,8 +5621,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -5951,8 +5651,7 @@
                 "goal_id": 1155
               },
               {
-                "goal_text":
-                  "std.map\n [att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X28",
+                "goal_text": "std.map\n [att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X28",
                 "goal_id": 1156
               }
             ],
@@ -5965,8 +5664,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -5985,8 +5683,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6005,8 +5702,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6025,8 +5721,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6045,8 +5740,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6065,8 +5759,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6085,8 +5778,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6105,8 +5797,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6125,8 +5816,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6145,8 +5835,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6165,8 +5854,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6185,8 +5873,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6205,8 +5892,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -6230,13 +5916,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -6251,8 +5935,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -6310,8 +5993,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6330,8 +6012,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6350,8 +6031,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6370,8 +6050,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6390,8 +6069,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6410,8 +6088,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6430,8 +6107,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6450,8 +6126,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6470,8 +6145,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6490,8 +6164,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6510,8 +6183,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6530,8 +6202,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6550,8 +6221,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -6575,13 +6245,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -6596,8 +6264,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -6629,8 +6296,7 @@
       "Inference",
       {
         "current_goal_id": 1156,
-        "current_goal_text":
-          "std.map\n [att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X28",
+        "current_goal_text": "std.map\n [att skip string, att local bool, att fail bool, att doc string, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X28",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -6639,8 +6305,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -6670,8 +6335,7 @@
                 "goal_id": 1157
               },
               {
-                "goal_text":
-                  "std.map\n [att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X30",
+                "goal_text": "std.map\n [att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X30",
                 "goal_id": 1158
               }
             ],
@@ -6684,8 +6348,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6704,8 +6367,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6724,8 +6386,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6744,8 +6405,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6764,8 +6424,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6784,8 +6443,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6804,8 +6462,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6824,8 +6481,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6844,8 +6500,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6864,8 +6519,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6884,8 +6538,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6904,8 +6557,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6924,8 +6576,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -6944,8 +6595,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -6969,13 +6619,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -6990,8 +6638,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -7049,8 +6696,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7069,8 +6715,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7089,8 +6734,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7109,8 +6753,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7129,8 +6772,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7149,8 +6791,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7169,8 +6810,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7189,8 +6829,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7209,8 +6848,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7229,8 +6867,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7249,8 +6886,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7269,8 +6905,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7289,8 +6924,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7309,8 +6943,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -7334,13 +6967,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -7355,8 +6986,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -7388,8 +7018,7 @@
       "Inference",
       {
         "current_goal_id": 1158,
-        "current_goal_text":
-          "std.map\n [att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X30",
+        "current_goal_text": "std.map\n [att local bool, att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X30",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -7398,8 +7027,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -7429,8 +7057,7 @@
                 "goal_id": 1159
               },
               {
-                "goal_text":
-                  "std.map\n [att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X32",
+                "goal_text": "std.map\n [att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X32",
                 "goal_id": 1160
               }
             ],
@@ -7443,8 +7070,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7463,8 +7089,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7483,8 +7108,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7503,8 +7127,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7523,8 +7146,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7543,8 +7165,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7563,8 +7184,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7583,8 +7203,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7603,8 +7222,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7623,8 +7241,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7643,8 +7260,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7663,8 +7279,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7683,8 +7298,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7703,8 +7317,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7723,8 +7336,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -7748,13 +7360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -7769,8 +7379,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -7828,8 +7437,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7848,8 +7456,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7868,8 +7475,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7888,8 +7494,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7908,8 +7513,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7928,8 +7532,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7948,8 +7551,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7968,8 +7570,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -7988,8 +7589,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8008,8 +7608,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8028,8 +7627,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8048,8 +7646,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8068,8 +7665,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8088,8 +7684,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8108,8 +7703,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -8133,13 +7727,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -8154,8 +7746,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -8187,8 +7778,7 @@
       "Inference",
       {
         "current_goal_id": 1160,
-        "current_goal_text":
-          "std.map\n [att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X32",
+        "current_goal_text": "std.map\n [att fail bool, att doc string, att primitive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X32",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -8197,8 +7787,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -8228,8 +7817,7 @@
                 "goal_id": 1161
               },
               {
-                "goal_text":
-                  "std.map\n [att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X34",
+                "goal_text": "std.map\n [att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X34",
                 "goal_id": 1162
               }
             ],
@@ -8242,8 +7830,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8262,8 +7849,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8282,8 +7868,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8302,8 +7887,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8322,8 +7906,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8342,8 +7925,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8362,8 +7944,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8382,8 +7963,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8402,8 +7982,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8422,8 +8001,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8442,8 +8020,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8462,8 +8039,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8482,8 +8058,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8502,8 +8077,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8522,8 +8096,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8542,8 +8115,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -8567,13 +8139,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -8588,8 +8158,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -8647,8 +8216,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8667,8 +8235,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8687,8 +8254,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8707,8 +8273,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8727,8 +8292,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8747,8 +8311,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8767,8 +8330,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8787,8 +8349,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8807,8 +8368,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8827,8 +8387,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8847,8 +8406,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8867,8 +8425,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8887,8 +8444,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8907,8 +8463,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8927,8 +8482,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -8947,8 +8501,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -8972,13 +8525,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -8993,8 +8544,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -9026,8 +8576,7 @@
       "Inference",
       {
         "current_goal_id": 1162,
-        "current_goal_text":
-          "std.map\n [att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X34",
+        "current_goal_text": "std.map\n [att doc string, att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X34",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -9036,8 +8585,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -9067,8 +8615,7 @@
                 "goal_id": 1163
               },
               {
-                "goal_text":
-                  "std.map\n [att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X36",
+                "goal_text": "std.map\n [att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X36",
                 "goal_id": 1164
               }
             ],
@@ -9081,8 +8628,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9101,8 +8647,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9121,8 +8666,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9141,8 +8685,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9161,8 +8704,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9181,8 +8723,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9201,8 +8742,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9221,8 +8761,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9241,8 +8780,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9261,8 +8799,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9281,8 +8818,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9301,8 +8837,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9321,8 +8856,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9341,8 +8875,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9361,8 +8894,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9381,8 +8913,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9401,8 +8932,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -9426,13 +8956,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -9447,8 +8975,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -9506,8 +9033,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9526,8 +9052,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9546,8 +9071,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9566,8 +9090,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9586,8 +9109,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9606,8 +9128,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9626,8 +9147,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9646,8 +9166,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9666,8 +9185,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9686,8 +9204,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9706,8 +9223,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9726,8 +9242,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9746,8 +9261,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9766,8 +9280,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9786,8 +9299,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9806,8 +9318,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9826,8 +9337,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -9851,13 +9361,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -9872,8 +9380,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -9905,8 +9412,7 @@
       "Inference",
       {
         "current_goal_id": 1164,
-        "current_goal_text":
-          "std.map\n [att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X36",
+        "current_goal_text": "std.map\n [att primitive_class bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X36",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -9915,8 +9421,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -9942,13 +9447,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X37 = supported-attribute (att primitive_class bool)",
+                "goal_text": "X37 = supported-attribute (att primitive_class bool)",
                 "goal_id": 1165
               },
               {
-                "goal_text":
-                  "std.map\n [att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X38",
+                "goal_text": "std.map\n [att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X38",
                 "goal_id": 1166
               }
             ],
@@ -9961,8 +9464,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -9981,8 +9483,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10001,8 +9502,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10021,8 +9521,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10041,8 +9540,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10061,8 +9559,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10081,8 +9578,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10101,8 +9597,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10121,8 +9616,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10141,8 +9635,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10161,8 +9654,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10181,8 +9673,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10201,8 +9692,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10221,8 +9711,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10241,8 +9730,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10261,8 +9749,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10281,8 +9768,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10301,8 +9787,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -10326,13 +9811,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -10347,8 +9830,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -10380,8 +9862,7 @@
       "Inference",
       {
         "current_goal_id": 1165,
-        "current_goal_text":
-          "X37 = supported-attribute (att primitive_class bool)",
+        "current_goal_text": "X37 = supported-attribute (att primitive_class bool)",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -10410,8 +9891,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10430,8 +9910,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10450,8 +9929,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10470,8 +9948,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10490,8 +9967,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10510,8 +9986,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10530,8 +10005,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10550,8 +10024,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10570,8 +10043,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10590,8 +10062,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10610,8 +10081,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10630,8 +10100,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10650,8 +10119,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10670,8 +10138,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10690,8 +10157,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10710,8 +10176,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10730,8 +10195,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10750,8 +10214,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -10775,13 +10238,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -10796,8 +10257,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -10829,8 +10289,7 @@
       "Inference",
       {
         "current_goal_id": 1166,
-        "current_goal_text":
-          "std.map\n [att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X38",
+        "current_goal_text": "std.map\n [att primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 = supported-attribute c0) X38",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -10839,8 +10298,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -10870,8 +10328,7 @@
                 "goal_id": 1167
               },
               {
-                "goal_text":
-                  "std.map [att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X40",
+                "goal_text": "std.map [att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X40",
                 "goal_id": 1168
               }
             ],
@@ -10884,8 +10341,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10904,8 +10360,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10924,8 +10379,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10944,8 +10398,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10964,8 +10417,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -10984,8 +10436,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11004,8 +10455,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11024,8 +10474,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11044,8 +10493,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11064,8 +10512,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11084,8 +10531,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11104,8 +10550,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11124,8 +10569,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11144,8 +10588,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11164,8 +10607,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11184,8 +10626,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11204,8 +10645,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11224,8 +10664,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11244,8 +10683,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -11269,13 +10707,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -11290,8 +10726,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -11351,8 +10786,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11371,8 +10805,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11391,8 +10824,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11411,8 +10843,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11431,8 +10862,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11451,8 +10881,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11471,8 +10900,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11491,8 +10919,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11511,8 +10938,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11531,8 +10957,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11551,8 +10976,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11571,8 +10995,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11591,8 +11014,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11611,8 +11033,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11631,8 +11052,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11651,8 +11071,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11671,8 +11090,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11691,8 +11109,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11711,8 +11128,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -11736,13 +11152,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -11757,8 +11171,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -11790,8 +11203,7 @@
       "Inference",
       {
         "current_goal_id": 1168,
-        "current_goal_text":
-          "std.map [att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X40",
+        "current_goal_text": "std.map [att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 = supported-attribute c0) X40",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -11800,8 +11212,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -11824,13 +11235,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X41 = supported-attribute (att non_forgetful_inheritance bool)",
+                "goal_text": "X41 = supported-attribute (att non_forgetful_inheritance bool)",
                 "goal_id": 1169
               },
               {
-                "goal_text":
-                  "std.map [att hnf bool] (c0 \\ c1 \\ c1 = supported-attribute c0) X42",
+                "goal_text": "std.map [att hnf bool] (c0 \\ c1 \\ c1 = supported-attribute c0) X42",
                 "goal_id": 1170
               }
             ],
@@ -11843,8 +11252,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11863,8 +11271,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11883,8 +11290,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11903,8 +11309,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11923,8 +11328,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11943,8 +11347,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11963,8 +11366,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -11983,8 +11385,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12003,8 +11404,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12023,8 +11423,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12043,8 +11442,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12063,8 +11461,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12083,8 +11480,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12103,8 +11499,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12123,8 +11518,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12143,8 +11537,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12163,8 +11556,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12183,8 +11575,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12203,8 +11594,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12223,8 +11613,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -12248,13 +11637,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -12269,8 +11656,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -12302,8 +11688,7 @@
       "Inference",
       {
         "current_goal_id": 1169,
-        "current_goal_text":
-          "X41 = supported-attribute (att non_forgetful_inheritance bool)",
+        "current_goal_text": "X41 = supported-attribute (att non_forgetful_inheritance bool)",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -12332,8 +11717,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12352,8 +11736,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12372,8 +11755,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12392,8 +11774,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12412,8 +11793,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12432,8 +11812,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12452,8 +11831,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12472,8 +11850,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12492,8 +11869,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12512,8 +11888,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12532,8 +11907,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12552,8 +11926,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12572,8 +11945,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12592,8 +11964,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12612,8 +11983,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12632,8 +12002,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12652,8 +12021,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12672,8 +12040,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12692,8 +12059,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12712,8 +12078,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -12737,13 +12102,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -12758,8 +12121,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -12791,8 +12153,7 @@
       "Inference",
       {
         "current_goal_id": 1170,
-        "current_goal_text":
-          "std.map [att hnf bool] (c0 \\ c1 \\ c1 = supported-attribute c0) X42",
+        "current_goal_text": "std.map [att hnf bool] (c0 \\ c1 \\ c1 = supported-attribute c0) X42",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -12801,8 +12162,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -12829,8 +12189,7 @@
                 "goal_id": 1171
               },
               {
-                "goal_text":
-                  "std.map [] (c0 \\ c1 \\ c1 = supported-attribute c0) X44",
+                "goal_text": "std.map [] (c0 \\ c1 \\ c1 = supported-attribute c0) X44",
                 "goal_id": 1172
               }
             ],
@@ -12843,8 +12202,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12863,8 +12221,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12883,8 +12240,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12903,8 +12259,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12923,8 +12278,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12943,8 +12297,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12963,8 +12316,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -12983,8 +12335,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13003,8 +12354,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13023,8 +12373,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13043,8 +12392,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13063,8 +12411,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13083,8 +12430,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13103,8 +12449,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13123,8 +12468,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13143,8 +12487,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13163,8 +12506,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13183,8 +12525,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13203,8 +12544,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13223,8 +12563,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13243,8 +12582,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -13268,13 +12606,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -13289,8 +12625,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -13348,8 +12683,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13368,8 +12702,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13388,8 +12721,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13408,8 +12740,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13428,8 +12759,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13448,8 +12778,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13468,8 +12797,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13488,8 +12816,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13508,8 +12835,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13528,8 +12854,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13548,8 +12873,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13568,8 +12892,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13588,8 +12911,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13608,8 +12930,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13628,8 +12949,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13648,8 +12968,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13668,8 +12987,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13688,8 +13006,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13708,8 +13025,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13728,8 +13044,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13748,8 +13063,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -13773,13 +13087,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -13794,8 +13106,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -13827,8 +13138,7 @@
       "Inference",
       {
         "current_goal_id": 1172,
-        "current_goal_text":
-          "std.map [] (c0 \\ c1 \\ c1 = supported-attribute c0) X44",
+        "current_goal_text": "std.map [] (c0 \\ c1 \\ c1 = supported-attribute c0) X44",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -13880,8 +13190,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13900,8 +13209,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13920,8 +13228,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13940,8 +13247,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13960,8 +13266,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -13980,8 +13285,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14000,8 +13304,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14020,8 +13323,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14040,8 +13342,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14060,8 +13361,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14080,8 +13380,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14100,8 +13399,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14120,8 +13418,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14140,8 +13437,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14160,8 +13456,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14180,8 +13475,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14200,8 +13494,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14220,8 +13513,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14240,8 +13532,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14260,8 +13551,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14280,8 +13570,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -14305,13 +13594,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -14326,8 +13613,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -14359,8 +13645,7 @@
       "Inference",
       {
         "current_goal_id": 1131,
-        "current_goal_text":
-          "[supported-attribute (att verbose bool), \n supported-attribute (att mathcomp bool), \n supported-attribute (att mathcomp.axiom string), \n supported-attribute (att short.type string), \n supported-attribute (att short.pack string), \n supported-attribute (att infer attmap), \n supported-attribute (att key string), \n supported-attribute (att arg_sort bool), \n supported-attribute (att log bool), supported-attribute (att log.raw bool), \n supported-attribute (att compress_coercions bool), \n supported-attribute (att export bool), \n supported-attribute (att skip string), \n supported-attribute (att local bool), supported-attribute (att fail bool), \n supported-attribute (att doc string), \n supported-attribute (att primitive_class bool), \n supported-attribute (att primitive bool), \n supported-attribute (att non_forgetful_inheritance bool), \n supported-attribute (att hnf bool)] =>\n parse-attributes.aux\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
+        "current_goal_text": "[supported-attribute (att verbose bool), \n supported-attribute (att mathcomp bool), \n supported-attribute (att mathcomp.axiom string), \n supported-attribute (att short.type string), \n supported-attribute (att short.pack string), \n supported-attribute (att infer attmap), \n supported-attribute (att key string), \n supported-attribute (att arg_sort bool), \n supported-attribute (att log bool), supported-attribute (att log.raw bool), \n supported-attribute (att compress_coercions bool), \n supported-attribute (att export bool), \n supported-attribute (att skip string), \n supported-attribute (att local bool), supported-attribute (att fail bool), \n supported-attribute (att doc string), \n supported-attribute (att primitive_class bool), \n supported-attribute (att primitive bool), \n supported-attribute (att non_forgetful_inheritance bool), \n supported-attribute (att hnf bool)] =>\n parse-attributes.aux\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -14371,8 +13656,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "parse-attributes.aux\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
+                "goal_text": "parse-attributes.aux\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
                 "goal_id": 1173
               }
             ],
@@ -14390,8 +13674,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -14415,13 +13698,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -14436,8 +13717,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -14469,16 +13749,14 @@
       "Inference",
       {
         "current_goal_id": 1173,
-        "current_goal_text":
-          "parse-attributes.aux\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
+        "current_goal_text": "parse-attributes.aux\n [attribute elpi.loc \n   (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
         "current_goal_predicate": "parse-attributes.aux",
         "failed_attempts": [
           {
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A5 = A0) \n                                                                (A5 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A5 attmap)), (!), \n (parse-attributes.aux A2 A3 A6), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A7), (std.append A6 [get-option A5 A7] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A5 = A0) \n                                                                (A5 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A5 attmap)), (!), \n (parse-attributes.aux A2 A3 A6), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A7), (std.append A6 [get-option A5 A7] A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14502,8 +13780,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (!), \n (parse-attributes.aux A2 A3 A5), \n (if (A3 = ) (A6 = A0) (A6 is A3 ^ . ^ A0)), \n (parse-attributes.aux A1 A6 A7), (std.append A5 A7 A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (!), \n (parse-attributes.aux A2 A3 A5), \n (if (A3 = ) (A6 = A0) (A6 is A3 ^ . ^ A0)), \n (parse-attributes.aux A1 A6 A7), (std.append A5 A7 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -14527,8 +13804,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (leaf-str A1) | A2] A3 A4) :- (!), \n (if (A3 = ) (A5 = A0) (A5 is A3 ^ . ^ A0)), \n (coq.valid-str-attribute A5 A1 A6 A7), \n (if (A7 = error A8) (coq.error A8) true), \n (if (A6 = some A9) (A4 = [get-option A5 A9 | A10]) (A4 = A10)), \n (parse-attributes.aux A2 A3 A10).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (leaf-str A1) | A2] A3 A4) :- (!), \n (if (A3 = ) (A5 = A0) (A5 is A3 ^ . ^ A0)), \n (coq.valid-str-attribute A5 A1 A6 A7), \n (if (A7 = error A8) (coq.error A8) true), \n (if (A6 = some A9) (A4 = [get-option A5 A9 | A10]) (A4 = A10)), \n (parse-attributes.aux A2 A3 A10).",
                 "rule_loc": [
                   "File",
                   {
@@ -14552,8 +13828,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (leaf-loc A1) | A2] A3 A4) :- (!), \n (if (A3 = ) (A5 = A0) (A5 is A3 ^ . ^ A0)), \n (coq.valid-loc-attribute A5 A1 A6), \n (if (A6 = error A7) (coq.error A7) true), (A4 = [get-option A5 A1 | A8]), \n (parse-attributes.aux A2 A3 A8).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (leaf-loc A1) | A2] A3 A4) :- (!), \n (if (A3 = ) (A5 = A0) (A5 is A3 ^ . ^ A0)), \n (coq.valid-loc-attribute A5 A1 A6), \n (if (A6 = error A7) (coq.error A7) true), (A4 = [get-option A5 A1 | A8]), \n (parse-attributes.aux A2 A3 A8).",
                 "rule_loc": [
                   "File",
                   {
@@ -14583,8 +13858,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                  "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                   "rule_loc": [ "Context", 6 ]
                 }
               ],
@@ -14599,13 +13873,11 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1174 },
               {
-                "goal_text":
-                  "if ( = ) (X45 = elpi.loc) (X45 is  ^ . ^ elpi.loc)",
+                "goal_text": "if ( = ) (X45 = elpi.loc) (X45 is  ^ . ^ elpi.loc)",
                 "goal_id": 1175
               },
               {
-                "goal_text":
-                  "coq.valid-loc-attribute X45 File \"(stdin)\", line 1, column 2, character 3: \n X46",
+                "goal_text": "coq.valid-loc-attribute X45 File \"(stdin)\", line 1, column 2, character 3: \n X46",
                 "goal_id": 1176
               },
               {
@@ -14613,8 +13885,7 @@
                 "goal_id": 1177
               },
               {
-                "goal_text":
-                  "X3 = [get-option X45 File \"(stdin)\", line 1, column 2, character 3: | X48]",
+                "goal_text": "X3 = [get-option X45 File \"(stdin)\", line 1, column 2, character 3: | X48]",
                 "goal_id": 1178
               },
               {
@@ -14631,8 +13902,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -14648,8 +13918,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -14673,13 +13942,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -14694,8 +13961,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -14733,8 +13999,7 @@
       "Inference",
       {
         "current_goal_id": 1175,
-        "current_goal_text":
-          "if ( = ) (X45 = elpi.loc) (X45 is  ^ . ^ elpi.loc)",
+        "current_goal_text": "if ( = ) (X45 = elpi.loc) (X45 is  ^ . ^ elpi.loc)",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -14793,8 +14058,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -14810,8 +14074,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -14835,13 +14098,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -14856,8 +14117,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -14932,8 +14192,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -14949,8 +14208,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -14974,13 +14232,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -14995,8 +14251,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -15031,8 +14286,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "if ( = ) (X45 = elpi.loc) (X45 is  ^ . ^ elpi.loc)",
+              "goal_text": "if ( = ) (X45 = elpi.loc) (X45 is  ^ . ^ elpi.loc)",
               "goal_id": 1175
             },
             "cut_branch": {
@@ -15103,8 +14357,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -15120,8 +14373,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -15145,13 +14397,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -15166,8 +14416,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -15199,8 +14448,7 @@
       "Inference",
       {
         "current_goal_id": 1176,
-        "current_goal_text":
-          "coq.valid-loc-attribute elpi.loc \n File \"(stdin)\", line 1, column 2, character 3: X46",
+        "current_goal_text": "coq.valid-loc-attribute elpi.loc \n File \"(stdin)\", line 1, column 2, character 3: X46",
         "current_goal_predicate": "coq.valid-loc-attribute",
         "failed_attempts": [],
         "successful_attempts": [
@@ -15209,8 +14457,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
+                  "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
                   "rule_loc": [
                     "File",
                     {
@@ -15233,8 +14480,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if (supported-attribute (att elpi.loc loc)) \n (if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n   (X46 = ok) \n   ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n      calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n     X46 = error X50)) \n (if (supported-attribute att-ignore-unknown) (X46 = ok) \n   (calc (Attribute  ^ elpi.loc ^  is not supported) X51 , X46 = error X51))",
+                "goal_text": "if (supported-attribute (att elpi.loc loc)) \n (if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n   (X46 = ok) \n   ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n      calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n     X46 = error X50)) \n (if (supported-attribute att-ignore-unknown) (X46 = ok) \n   (calc (Attribute  ^ elpi.loc ^  is not supported) X51 , X46 = error X51))",
                 "goal_id": 1183
               }
             ],
@@ -15247,8 +14493,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
                 "rule_loc": [
                   "File",
                   {
@@ -15267,8 +14512,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -15284,8 +14528,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -15309,13 +14552,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -15330,8 +14571,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -15363,8 +14603,7 @@
       "Inference",
       {
         "current_goal_id": 1183,
-        "current_goal_text":
-          "if (supported-attribute (att elpi.loc loc)) \n (if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n   (X46 = ok) \n   ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n      calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n     X46 = error X50)) \n (if (supported-attribute att-ignore-unknown) (X46 = ok) \n   (calc (Attribute  ^ elpi.loc ^  is not supported) X51 , X46 = error X51))",
+        "current_goal_text": "if (supported-attribute (att elpi.loc loc)) \n (if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n   (X46 = ok) \n   ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n      calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n     X46 = error X50)) \n (if (supported-attribute att-ignore-unknown) (X46 = ok) \n   (calc (Attribute  ^ elpi.loc ^  is not supported) X51 , X46 = error X51))",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -15400,8 +14639,7 @@
               },
               { "goal_text": "!", "goal_id": 1185 },
               {
-                "goal_text":
-                  "if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n (X46 = ok) \n ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n    calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n   X46 = error X50)",
+                "goal_text": "if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n (X46 = ok) \n ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n    calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n   X46 = error X50)",
                 "goal_id": 1186
               }
             ],
@@ -15433,8 +14671,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
                 "rule_loc": [
                   "File",
                   {
@@ -15453,8 +14690,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -15470,8 +14706,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -15495,13 +14730,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -15516,8 +14749,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -15568,8 +14800,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(supported-attribute (att mathcomp.axiom string)) :- .",
+                "rule_text": "(supported-attribute (att mathcomp.axiom string)) :- .",
                 "rule_loc": [ "Context", 49 ]
               }
             ],
@@ -15584,8 +14815,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(supported-attribute (att short.type string)) :- .",
+                "rule_text": "(supported-attribute (att short.type string)) :- .",
                 "rule_loc": [ "Context", 49 ]
               }
             ],
@@ -15597,8 +14827,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(supported-attribute (att short.pack string)) :- .",
+                "rule_text": "(supported-attribute (att short.pack string)) :- .",
                 "rule_loc": [ "Context", 49 ]
               }
             ],
@@ -15670,8 +14899,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(supported-attribute (att compress_coercions bool)) :- .",
+                "rule_text": "(supported-attribute (att compress_coercions bool)) :- .",
                 "rule_loc": [ "Context", 49 ]
               }
             ],
@@ -15746,8 +14974,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(supported-attribute (att primitive_class bool)) :- .",
+                "rule_text": "(supported-attribute (att primitive_class bool)) :- .",
                 "rule_loc": [ "Context", 49 ]
               }
             ],
@@ -15762,8 +14989,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(supported-attribute (att primitive bool)) :- .",
+                "rule_text": "(supported-attribute (att primitive bool)) :- .",
                 "rule_loc": [ "Context", 49 ]
               }
             ],
@@ -15775,8 +15001,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(supported-attribute (att non_forgetful_inheritance bool)) :- .",
+                "rule_text": "(supported-attribute (att non_forgetful_inheritance bool)) :- .",
                 "rule_loc": [ "Context", 49 ]
               }
             ],
@@ -15824,8 +15049,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(supported-attribute (att verbose bool)) :- .",
+                  "rule_text": "(supported-attribute (att verbose bool)) :- .",
                   "rule_loc": [ "Context", 49 ]
                 }
               ],
@@ -15873,8 +15097,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
                 "rule_loc": [
                   "File",
                   {
@@ -15893,8 +15116,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -15910,8 +15132,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -15935,13 +15156,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -15956,8 +15175,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -15996,8 +15214,7 @@
               "goal_id": 1184
             },
             "cut_branch": {
-              "rule_text":
-                "(supported-attribute (att A0 string)) :- (rex_match ^elpi\\. A0).",
+              "rule_text": "(supported-attribute (att A0 string)) :- (rex_match ^elpi\\. A0).",
               "rule_loc": [
                 "File",
                 {
@@ -16011,8 +15228,7 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "if (supported-attribute (att elpi.loc loc)) \n (if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n   (X46 = ok) \n   ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n      calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n     X46 = error X50)) \n (if (supported-attribute att-ignore-unknown) (X46 = ok) \n   (calc (Attribute  ^ elpi.loc ^  is not supported) X51 , X46 = error X51))",
+              "goal_text": "if (supported-attribute (att elpi.loc loc)) \n (if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n   (X46 = ok) \n   ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n      calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n     X46 = error X50)) \n (if (supported-attribute att-ignore-unknown) (X46 = ok) \n   (calc (Attribute  ^ elpi.loc ^  is not supported) X51 , X46 = error X51))",
               "goal_id": 1183
             },
             "cut_branch": {
@@ -16040,8 +15256,7 @@
       "Inference",
       {
         "current_goal_id": 1186,
-        "current_goal_text":
-          "if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n (X46 = ok) \n ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n    calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n   X46 = error X50)",
+        "current_goal_text": "if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n (X46 = ok) \n ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n    calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n   X46 = error X50)",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -16072,8 +15287,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t",
+                "goal_text": "primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t",
                 "goal_id": 1187
               },
               { "goal_text": "!", "goal_id": 1188 },
@@ -16126,8 +15340,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
                 "rule_loc": [
                   "File",
                   {
@@ -16146,8 +15359,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -16163,8 +15375,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -16188,13 +15399,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -16209,8 +15418,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -16242,8 +15450,7 @@
       "Inference",
       {
         "current_goal_id": 1187,
-        "current_goal_text":
-          "primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t",
+        "current_goal_text": "primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t",
         "current_goal_predicate": "primitive?",
         "failed_attempts": [],
         "successful_attempts": [
@@ -16252,8 +15459,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(primitive? A0 A1) :- (is_cdata A0 (ctype A1)).",
+                  "rule_text": "(primitive? A0 A1) :- (is_cdata A0 (ctype A1)).",
                   "rule_loc": [
                     "File",
                     {
@@ -16275,8 +15481,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "is_cdata File \"(stdin)\", line 1, column 2, character 3: (ctype Loc.t)",
+                "goal_text": "is_cdata File \"(stdin)\", line 1, column 2, character 3: (ctype Loc.t)",
                 "goal_id": 1190
               }
             ],
@@ -16289,8 +15494,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(primitive? A0 A1) :- (is_cdata A0 (ctype A1)).",
+                "rule_text": "(primitive? A0 A1) :- (is_cdata A0 (ctype A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -16347,8 +15551,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
                 "rule_loc": [
                   "File",
                   {
@@ -16367,8 +15570,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -16384,8 +15586,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -16409,13 +15610,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -16430,8 +15629,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -16463,8 +15661,7 @@
       "Inference",
       {
         "current_goal_id": 1190,
-        "current_goal_text":
-          "is_cdata File \"(stdin)\", line 1, column 2, character 3: (ctype Loc.t)",
+        "current_goal_text": "is_cdata File \"(stdin)\", line 1, column 2, character 3: (ctype Loc.t)",
         "current_goal_predicate": "is_cdata",
         "failed_attempts": [],
         "successful_attempts": [
@@ -16490,8 +15687,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(primitive? A0 A1) :- (is_cdata A0 (ctype A1)).",
+                "rule_text": "(primitive? A0 A1) :- (is_cdata A0 (ctype A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -16548,8 +15744,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
                 "rule_loc": [
                   "File",
                   {
@@ -16568,8 +15763,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -16585,8 +15779,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -16610,13 +15803,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -16631,8 +15822,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -16693,8 +15883,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(primitive? A0 A1) :- (is_cdata A0 (ctype A1)).",
+                "rule_text": "(primitive? A0 A1) :- (is_cdata A0 (ctype A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -16751,8 +15940,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
                 "rule_loc": [
                   "File",
                   {
@@ -16771,8 +15959,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -16788,8 +15975,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -16813,13 +15999,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -16834,8 +16018,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -16870,8 +16053,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n (X46 = ok) \n ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n    calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n   X46 = error X50)",
+              "goal_text": "if (primitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n (X46 = ok) \n ((std.any->string File \"(stdin)\", line 1, column 2, character 3: X49 ,\n    calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X50) ,\n   X46 = error X50)",
               "goal_id": 1186
             },
             "cut_branch": {
@@ -16961,8 +16143,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-attribute (att A0 loc)) \n                                        (if (primitive? A1 Loc.t) (A2 = ok) \n                                          ((std.any->string A1 A4 ,\n                                             calc\n                                              (Attribute  ^ A0 ^\n                                                 takes a loc, got  ^ A4) A5)\n                                            , A2 = error A5)) \n                                        (if\n                                          (supported-attribute\n                                            att-ignore-unknown) (A2 = ok) \n                                          (calc\n                                            (Attribute  ^ A0 ^\n                                               is not supported) A3 ,\n                                            A2 = error A3))).",
                 "rule_loc": [
                   "File",
                   {
@@ -16981,8 +16162,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -16998,8 +16178,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -17023,13 +16202,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -17044,8 +16221,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -17136,8 +16312,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -17153,8 +16328,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -17178,13 +16352,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -17199,8 +16371,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -17271,8 +16442,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -17288,8 +16458,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -17313,13 +16482,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -17334,8 +16501,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -17419,8 +16585,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -17436,8 +16601,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -17461,13 +16625,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -17482,8 +16644,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -17586,8 +16747,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -17603,8 +16763,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -17628,13 +16787,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -17649,8 +16806,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -17682,8 +16838,7 @@
       "Inference",
       {
         "current_goal_id": 1178,
-        "current_goal_text":
-          "X3 =\n [get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3: | X48]",
+        "current_goal_text": "X3 =\n [get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3: | X48]",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -17712,8 +16867,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -17729,8 +16883,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -17754,13 +16907,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -17775,8 +16926,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -17860,8 +17010,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 A4) :- (if (A3 = ) \n                                                                (A7 = A0) \n                                                                (A7 is\n                                                                  A3 ^ . ^ A0)), \n (supported-attribute (att A7 attmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-attribute (att c0 string) :- !)) =>\n   parse-attributes.aux A1  A6), (std.append A5 [get-option A7 A6] A4).",
                 "rule_loc": [ "Context", 6 ]
               }
             ],
@@ -17877,8 +17026,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map A1 (c0 \\ (c1 \\\n                                     (c1 = supported-attribute c0))) A3), \n (A3 => parse-attributes.aux A0  A2), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -17902,13 +17050,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -17923,8 +17069,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -17968,8 +17113,7 @@
       "Inference",
       {
         "current_goal_id": 1128,
-        "current_goal_text":
-          "[get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:] =>\n (save-docstring ,\n   with-logging\n    (instance.declare-const _ \n      (app\n        [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n         global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _))",
+        "current_goal_text": "[get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:] =>\n (save-docstring ,\n   with-logging\n    (instance.declare-const _ \n      (app\n        [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n         global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _))",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -17980,8 +17124,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "save-docstring ,\n with-logging\n  (instance.declare-const _ \n    (app\n      [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n       global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
+                "goal_text": "save-docstring ,\n with-logging\n  (instance.declare-const _ \n    (app\n      [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n       global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
                 "goal_id": 1196
               }
             ],
@@ -17999,13 +17142,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -18020,8 +17161,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -18053,8 +17193,7 @@
       "Inference",
       {
         "current_goal_id": 1196,
-        "current_goal_text":
-          "save-docstring ,\n with-logging\n  (instance.declare-const _ \n    (app\n      [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n       global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
+        "current_goal_text": "save-docstring ,\n with-logging\n  (instance.declare-const _ \n    (app\n      [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n       global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
         "current_goal_predicate": ",",
         "failed_attempts": [],
         "successful_attempts": [
@@ -18066,8 +17205,7 @@
             "siblings": [
               { "goal_text": "save-docstring", "goal_id": 1197 },
               {
-                "goal_text":
-                  "with-logging\n (instance.declare-const _ \n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
+                "goal_text": "with-logging\n (instance.declare-const _ \n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
                 "goal_id": 1198
               }
             ],
@@ -18090,13 +17228,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -18111,8 +17247,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -18153,13 +17288,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                  "rule_text": "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 81,
                       "column": 0,
                       "character": 2429
@@ -18171,8 +17304,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if (get-option elpi.loc X52 , get-option doc X53) \n (acc-clause _ (docstring X52 X53)) true",
+                "goal_text": "if (get-option elpi.loc X52 , get-option doc X53) \n (acc-clause _ (docstring X52 X53)) true",
                 "goal_id": 1199
               }
             ],
@@ -18185,13 +17317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 81,
                     "column": 0,
                     "character": 2429
@@ -18216,13 +17346,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -18237,8 +17365,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -18270,8 +17397,7 @@
       "Inference",
       {
         "current_goal_id": 1199,
-        "current_goal_text":
-          "if (get-option elpi.loc X52 , get-option doc X53) \n (acc-clause _ (docstring X52 X53)) true",
+        "current_goal_text": "if (get-option elpi.loc X52 , get-option doc X53) \n (acc-clause _ (docstring X52 X53)) true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -18339,13 +17465,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 81,
                     "column": 0,
                     "character": 2429
@@ -18370,13 +17494,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -18391,8 +17513,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -18470,13 +17591,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 81,
                     "column": 0,
                     "character": 2429
@@ -18501,13 +17620,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -18522,8 +17639,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -18564,8 +17680,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:) :- .",
+                  "rule_text": "(get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:) :- .",
                   "rule_loc": [ "Context", 74 ]
                 }
               ],
@@ -18586,8 +17701,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:) :- .",
+                "rule_text": "(get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:) :- .",
                 "rule_loc": [ "Context", 74 ]
               }
             ],
@@ -18622,13 +17736,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 81,
                     "column": 0,
                     "character": 2429
@@ -18653,13 +17765,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -18674,8 +17784,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -18741,13 +17850,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 81,
                     "column": 0,
                     "character": 2429
@@ -18772,13 +17879,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -18793,8 +17898,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -18826,8 +17930,7 @@
       "Inference",
       {
         "current_goal_id": 1199,
-        "current_goal_text":
-          "if (get-option elpi.loc X52 , get-option doc X53) \n (acc-clause _ (docstring X52 X53)) true",
+        "current_goal_text": "if (get-option elpi.loc X52 , get-option doc X53) \n (acc-clause _ (docstring X52 X53)) true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -18879,13 +17982,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 81,
                     "column": 0,
                     "character": 2429
@@ -18910,13 +18011,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -18931,8 +18030,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -19035,13 +18133,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 81,
                     "column": 0,
                     "character": 2429
@@ -19066,13 +18162,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -19087,8 +18181,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -19120,8 +18213,7 @@
       "Inference",
       {
         "current_goal_id": 1198,
-        "current_goal_text":
-          "with-logging\n (instance.declare-const _ \n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
+        "current_goal_text": "with-logging\n (instance.declare-const _ \n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
         "current_goal_predicate": "with-logging",
         "failed_attempts": [],
         "successful_attempts": [
@@ -19130,13 +18222,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
+                  "rule_text": "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 267,
                       "column": 0,
                       "character": 10575
@@ -19153,8 +18243,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "get-option elpi.hb.log _ , X54 = tt ; get-option elpi.hb.log.raw _ , X54 = ff",
+                "goal_text": "get-option elpi.hb.log _ , X54 = tt ; get-option elpi.hb.log.raw _ , X54 = ff",
                 "goal_id": 1206
               },
               { "goal_text": "!", "goal_id": 1207 },
@@ -19164,15 +18253,13 @@
               { "goal_text": "X58 is X56 ^ .hb", "goal_id": 1211 },
               { "goal_text": "open_append X58 X59", "goal_id": 1212 },
               {
-                "goal_text":
-                  "std.string.concat \n [, HIERARCHY BUILDER PATCH v1, X57, ] X60",
+                "goal_text": "std.string.concat \n [, HIERARCHY BUILDER PATCH v1, X57, ] X60",
                 "goal_id": 1213
               },
               { "goal_text": "output X59 X60", "goal_id": 1214 },
               { "goal_text": "close_out X59", "goal_id": 1215 },
               {
-                "goal_text":
-                  "log.private.logger X61 X54 =>\n instance.declare-const _ \n  (app\n    [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n     global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _",
+                "goal_text": "log.private.logger X61 X54 =>\n instance.declare-const _ \n  (app\n    [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n     global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _",
                 "goal_id": 1216
               },
               {
@@ -19184,8 +18271,7 @@
                 "goal_id": 1218
               },
               {
-                "goal_text":
-                  "coq.pp->string (coq.pp.box (coq.pp.v 0) X62) X63",
+                "goal_text": "coq.pp->string (coq.pp.box (coq.pp.v 0) X62) X63",
                 "goal_id": 1219
               },
               { "goal_text": "open_append X58 X64", "goal_id": 1220 },
@@ -19201,13 +18287,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
+                "rule_text": "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 267,
                     "column": 0,
                     "character": 10575
@@ -19232,13 +18316,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -19253,8 +18335,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -19286,8 +18367,7 @@
       "Inference",
       {
         "current_goal_id": 1206,
-        "current_goal_text":
-          "get-option elpi.hb.log _ , X54 = tt ; get-option elpi.hb.log.raw _ , X54 = ff",
+        "current_goal_text": "get-option elpi.hb.log _ , X54 = tt ; get-option elpi.hb.log.raw _ , X54 = ff",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -19346,13 +18426,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
+                "rule_text": "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 267,
                     "column": 0,
                     "character": 10575
@@ -19377,13 +18455,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -19398,8 +18474,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -19477,13 +18552,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
+                "rule_text": "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 267,
                     "column": 0,
                     "character": 10575
@@ -19508,13 +18581,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -19529,8 +18600,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -19596,13 +18666,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
+                "rule_text": "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 267,
                     "column": 0,
                     "character": 10575
@@ -19627,13 +18695,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -19648,8 +18714,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -19681,8 +18746,7 @@
       "Inference",
       {
         "current_goal_id": 1206,
-        "current_goal_text":
-          "get-option elpi.hb.log _ , X54 = tt ; get-option elpi.hb.log.raw _ , X54 = ff",
+        "current_goal_text": "get-option elpi.hb.log _ , X54 = tt ; get-option elpi.hb.log.raw _ , X54 = ff",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -19741,13 +18805,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
+                "rule_text": "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 267,
                     "column": 0,
                     "character": 10575
@@ -19772,13 +18834,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -19793,8 +18853,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -19875,13 +18934,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
+                "rule_text": "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 267,
                     "column": 0,
                     "character": 10575
@@ -19906,13 +18963,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -19927,8 +18982,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -19994,13 +19048,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
+                "rule_text": "(with-logging A0) :- (get-option elpi.hb.log _ , A1 = tt ;\n                       get-option elpi.hb.log.raw _ , A1 = ff), (!), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->string A2 A4), (A5 is A3 ^ .hb), (open_append A5 A6), \n (std.string.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_out A6), (log.private.logger A8 A1 => A0), \n (log.private.logger-close A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 267,
                     "column": 0,
                     "character": 10575
@@ -20025,13 +19077,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -20046,8 +19096,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -20079,8 +19128,7 @@
       "Inference",
       {
         "current_goal_id": 1198,
-        "current_goal_text":
-          "with-logging\n (instance.declare-const _ \n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
+        "current_goal_text": "with-logging\n (instance.declare-const _ \n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
         "current_goal_predicate": "with-logging",
         "failed_attempts": [],
         "successful_attempts": [
@@ -20089,13 +19137,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
+                  "rule_text": "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 283,
                       "column": 0,
                       "character": 11151
@@ -20112,14 +19158,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "get-option log tt , X65 = tt ; get-option log.raw tt , X65 = ff",
+                "goal_text": "get-option log tt , X65 = tt ; get-option log.raw tt , X65 = ff",
                 "goal_id": 1229
               },
               { "goal_text": "!", "goal_id": 1230 },
               {
-                "goal_text":
-                  "log.private.logger X66 X65 =>\n instance.declare-const _ \n  (app\n    [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n     global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _",
+                "goal_text": "log.private.logger X66 X65 =>\n instance.declare-const _ \n  (app\n    [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n     global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _",
                 "goal_id": 1231
               },
               {
@@ -20131,8 +19175,7 @@
                 "goal_id": 1233
               },
               {
-                "goal_text":
-                  "coq.pp->string (coq.pp.box (coq.pp.v 0) X67) X68",
+                "goal_text": "coq.pp->string (coq.pp.box (coq.pp.v 0) X67) X68",
                 "goal_id": 1234
               },
               { "goal_text": "coq.say (* \n X68 \n*)", "goal_id": 1235 }
@@ -20146,13 +19189,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
+                "rule_text": "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 283,
                     "column": 0,
                     "character": 11151
@@ -20177,13 +19218,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -20198,8 +19237,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -20231,8 +19269,7 @@
       "Inference",
       {
         "current_goal_id": 1229,
-        "current_goal_text":
-          "get-option log tt , X65 = tt ; get-option log.raw tt , X65 = ff",
+        "current_goal_text": "get-option log tt , X65 = tt ; get-option log.raw tt , X65 = ff",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -20291,13 +19328,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
+                "rule_text": "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 283,
                     "column": 0,
                     "character": 11151
@@ -20322,13 +19357,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -20343,8 +19376,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -20422,13 +19454,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
+                "rule_text": "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 283,
                     "column": 0,
                     "character": 11151
@@ -20453,13 +19483,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -20474,8 +19502,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -20541,13 +19568,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
+                "rule_text": "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 283,
                     "column": 0,
                     "character": 11151
@@ -20572,13 +19597,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -20593,8 +19616,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -20626,8 +19648,7 @@
       "Inference",
       {
         "current_goal_id": 1229,
-        "current_goal_text":
-          "get-option log tt , X65 = tt ; get-option log.raw tt , X65 = ff",
+        "current_goal_text": "get-option log tt , X65 = tt ; get-option log.raw tt , X65 = ff",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -20686,13 +19707,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
+                "rule_text": "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 283,
                     "column": 0,
                     "character": 11151
@@ -20717,13 +19736,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -20738,8 +19755,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -20817,13 +19833,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
+                "rule_text": "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 283,
                     "column": 0,
                     "character": 11151
@@ -20848,13 +19862,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -20869,8 +19881,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -20936,13 +19947,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
+                "rule_text": "(with-logging A0) :- (get-option log tt , A1 = tt ;\n                       get-option log.raw tt , A1 = ff), (!), \n (log.private.logger A2 A1 => A0), (log.private.logger-close A2), \n (std.intersperse coq.pp.spc A2 A3), \n (coq.pp->string (coq.pp.box (coq.pp.v 0) A3) A4), (coq.say (* \n A4 \n*)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 283,
                     "column": 0,
                     "character": 11151
@@ -20967,13 +19976,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -20988,8 +19995,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -21021,8 +20027,7 @@
       "Inference",
       {
         "current_goal_id": 1198,
-        "current_goal_text":
-          "with-logging\n (instance.declare-const _ \n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
+        "current_goal_text": "with-logging\n (instance.declare-const _ \n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _)",
         "current_goal_predicate": "with-logging",
         "failed_attempts": [],
         "successful_attempts": [
@@ -21035,8 +20040,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 289,
                       "column": 0,
                       "character": 11419
@@ -21053,8 +20057,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "instance.declare-const _ \n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _",
+                "goal_text": "instance.declare-const _ \n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _",
                 "goal_id": 1242
               }
             ],
@@ -21071,8 +20074,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -21097,13 +20099,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -21118,8 +20118,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -21151,8 +20150,7 @@
       "Inference",
       {
         "current_goal_id": 1242,
-        "current_goal_text":
-          "instance.declare-const _ \n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _",
+        "current_goal_text": "instance.declare-const _ \n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` X0 c0 \\ c0]) (arity X1) _",
         "current_goal_predicate": "instance.declare-const",
         "failed_attempts": [],
         "successful_attempts": [
@@ -21161,13 +20159,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                  "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 25,
                       "column": 0,
                       "character": 1064
@@ -21186,8 +20182,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n   Definition type illtyped, coq.arity->term X69 X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (X69 = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity X69 [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (X69 = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n   Definition type illtyped, coq.arity->term X69 X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (X69 = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity X69 [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (X69 = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1243
               }
             ],
@@ -21200,13 +20195,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -21225,8 +20218,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -21251,13 +20243,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -21272,8 +20262,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -21305,8 +20294,7 @@
       "Inference",
       {
         "current_goal_id": 1243,
-        "current_goal_text":
-          "std.do!\n [std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n   Definition type illtyped, coq.arity->term X69 X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (X69 = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity X69 [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (X69 = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n   Definition type illtyped, coq.arity->term X69 X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (X69 = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity X69 [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (X69 = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -21315,8 +20303,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -21341,14 +20328,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n Definition type illtyped",
+                "goal_text": "std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n Definition type illtyped",
                 "goal_id": 1244
               },
               { "goal_text": "!", "goal_id": 1245 },
               {
-                "goal_text":
-                  "std.do!\n [coq.arity->term X69 X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (X69 = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity X69 [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (X69 = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [coq.arity->term X69 X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (X69 = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity X69 [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (X69 = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1246
               }
             ],
@@ -21380,13 +20365,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -21405,8 +20388,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -21431,13 +20413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -21452,8 +20432,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -21485,8 +20464,7 @@
       "Inference",
       {
         "current_goal_id": 1244,
-        "current_goal_text":
-          "std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n Definition type illtyped",
+        "current_goal_text": "std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n Definition type illtyped",
         "current_goal_predicate": "std.assert-ok!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -21495,8 +20473,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                  "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -21518,14 +20495,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.elaborate-arity-skeleton (arity X1) _ X69 X92",
+                "goal_text": "coq.elaborate-arity-skeleton (arity X1) _ X69 X92",
                 "goal_id": 1247
               },
               { "goal_text": "!", "goal_id": 1248 },
               {
-                "goal_text":
-                  "X92 = ok ;\n X92 = error X93 , std.fatal-error-w-data Definition type illtyped X93",
+                "goal_text": "X92 = ok ;\n X92 = error X93 , std.fatal-error-w-data Definition type illtyped X93",
                 "goal_id": 1249
               },
               { "goal_text": "!", "goal_id": 1250 }
@@ -21539,8 +20514,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -21578,13 +20552,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -21603,8 +20575,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -21629,13 +20600,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -21650,8 +20619,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -21683,8 +20651,7 @@
       "Inference",
       {
         "current_goal_id": 1247,
-        "current_goal_text":
-          "coq.elaborate-arity-skeleton (arity X1) _ X69 X92",
+        "current_goal_text": "coq.elaborate-arity-skeleton (arity X1) _ X69 X92",
         "current_goal_predicate": "coq.elaborate-arity-skeleton",
         "failed_attempts": [],
         "successful_attempts": [
@@ -21693,8 +20660,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
+                  "rule_text": "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
                   "rule_loc": [
                     "File",
                     {
@@ -21727,8 +20693,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
+                "rule_text": "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -21747,8 +20712,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -21786,13 +20750,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -21811,8 +20773,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -21837,13 +20798,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -21858,8 +20817,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -21898,8 +20856,7 @@
           {
             "attempt": {
               "rule": [
-                "BuiltinRule",
-                [ "FFI", "coq.elaborate-ty-skeleton" ]
+                "BuiltinRule", [ "FFI", "coq.elaborate-ty-skeleton" ]
               ],
               "events": []
             },
@@ -21910,8 +20867,7 @@
               },
               { "goal_text": "X94 = X96", "goal_id": 1253 },
               {
-                "goal_text":
-                  "declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)",
+                "goal_text": "declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)",
                 "goal_id": 1254
               },
               { "goal_text": "X92 = ok", "goal_id": 1255 }
@@ -21930,8 +20886,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
+                "rule_text": "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -21950,8 +20905,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -21989,13 +20943,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -22014,8 +20966,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -22040,13 +20991,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -22061,8 +21010,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -22125,8 +21073,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
+                "rule_text": "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -22145,8 +21092,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -22184,13 +21130,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -22209,8 +21153,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -22235,13 +21178,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -22256,8 +21197,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -22318,8 +21258,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
+                "rule_text": "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -22338,8 +21277,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -22377,13 +21315,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -22402,8 +21338,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -22428,13 +21363,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -22449,8 +21382,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -22482,8 +21414,7 @@
       "Inference",
       {
         "current_goal_id": 1254,
-        "current_goal_text":
-          "declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)",
+        "current_goal_text": "declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)",
         "current_goal_predicate": "declare-evar",
         "failed_attempts": [],
         "successful_attempts": [
@@ -22492,8 +21423,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(declare-evar A0 A1 A2 A3) :- (declare_constraint (declare-evar A0 A1 A2 A3) \n                                [A1]).",
+                  "rule_text": "(declare-evar A0 A1 A2 A3) :- (declare_constraint (declare-evar A0 A1 A2 A3) \n                                [A1]).",
                   "rule_loc": [
                     "File",
                     {
@@ -22514,8 +21444,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "declare_constraint\n (declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)) [\n X97]",
+                "goal_text": "declare_constraint\n (declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)) [\n X97]",
                 "goal_id": 1256
               }
             ],
@@ -22528,8 +21457,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(declare-evar A0 A1 A2 A3) :- (declare_constraint (declare-evar A0 A1 A2 A3) \n                                [A1]).",
+                "rule_text": "(declare-evar A0 A1 A2 A3) :- (declare_constraint (declare-evar A0 A1 A2 A3) \n                                [A1]).",
                 "rule_loc": [
                   "File",
                   {
@@ -22553,8 +21481,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
+                "rule_text": "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -22573,8 +21500,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -22612,13 +21538,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -22637,8 +21561,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -22663,13 +21586,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -22684,8 +21605,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -22717,11 +21637,9 @@
       "Suspend",
       {
         "suspend_goal_id": 1256,
-        "suspend_goal_text":
-          "declare_constraint\n (declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)) [\n X97]",
+        "suspend_goal_text": "declare_constraint\n (declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)) [\n X97]",
         "suspend_sibling": {
-          "goal_text":
-            "declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)",
+          "goal_text": "declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)",
           "goal_id": 1257
         },
         "suspend_stack": [
@@ -22734,8 +21652,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(declare-evar A0 A1 A2 A3) :- (declare_constraint (declare-evar A0 A1 A2 A3) \n                                [A1]).",
+                "rule_text": "(declare-evar A0 A1 A2 A3) :- (declare_constraint (declare-evar A0 A1 A2 A3) \n                                [A1]).",
                 "rule_loc": [
                   "File",
                   {
@@ -22759,8 +21676,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
+                "rule_text": "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -22779,8 +21695,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -22818,13 +21733,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -22843,8 +21756,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -22869,13 +21781,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -22890,8 +21800,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -22926,8 +21835,7 @@
         "chr_successful_attempts": [
           {
             "chr_attempt": {
-              "chr_text":
-                " \\ (declare-evar A0 A1 A2 A3)  <=> (A0 => evar A1 A2 A3)",
+              "chr_text": " \\ (declare-evar A0 A1 A2 A3)  <=> (A0 => evar A1 A2 A3)",
               "chr_loc": {
                 "filename": "coq-builtin.elpi",
                 "line": 178,
@@ -22939,8 +21847,7 @@
                   "step_id": 0,
                   "runtime_id": 9,
                   "step": [
-                    "Init",
-                    { "goal_text": "true", "goal_id": 1259 }
+                    "Init", { "goal_text": "true", "goal_id": 1259 }
                   ],
                   "color": "Grey"
                 },
@@ -23009,8 +21916,7 @@
             "chr_removed_goals": [ 1257 ],
             "chr_new_goals": [
               {
-                "goal_text":
-                  "_ => [] => evar X97 (sort (typ «interleave_context.403»)) X96",
+                "goal_text": "_ => [] => evar X97 (sort (typ «interleave_context.403»)) X96",
                 "goal_id": 1260
               }
             ]
@@ -23018,8 +21924,7 @@
         ],
         "chr_store_before": [
           {
-            "goal_text":
-              " declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)  /* suspended on X97 */",
+            "goal_text": " declare-evar [] (X97) (sort (typ «interleave_context.403»)) (X96)  /* suspended on X97 */",
             "goal_id": 1257
           }
         ],
@@ -23035,8 +21940,7 @@
       "Inference",
       {
         "current_goal_id": 1260,
-        "current_goal_text":
-          "_ => [] => evar X97 (sort (typ «interleave_context.403»)) X96",
+        "current_goal_text": "_ => [] => evar X97 (sort (typ «interleave_context.403»)) X96",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -23047,8 +21951,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "[] => evar X97 (sort (typ «interleave_context.403»)) X96",
+                "goal_text": "[] => evar X97 (sort (typ «interleave_context.403»)) X96",
                 "goal_id": 1261
               }
             ],
@@ -23074,8 +21977,7 @@
       "Inference",
       {
         "current_goal_id": 1261,
-        "current_goal_text":
-          "[] => evar X97 (sort (typ «interleave_context.403»)) X96",
+        "current_goal_text": "[] => evar X97 (sort (typ «interleave_context.403»)) X96",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -23086,8 +21988,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "evar X97 (sort (typ «interleave_context.403»)) X96",
+                "goal_text": "evar X97 (sort (typ «interleave_context.403»)) X96",
                 "goal_id": 1262
               }
             ],
@@ -23118,8 +22019,7 @@
       "Inference",
       {
         "current_goal_id": 1262,
-        "current_goal_text":
-          "evar X97 (sort (typ «interleave_context.403»)) X96",
+        "current_goal_text": "evar X97 (sort (typ «interleave_context.403»)) X96",
         "current_goal_predicate": "evar",
         "failed_attempts": [],
         "successful_attempts": [
@@ -23128,8 +22028,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                  "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                   "rule_loc": [
                     "File",
                     {
@@ -23150,8 +22049,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1263 },
               {
-                "goal_text":
-                  "if (var X96) \n (declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n   [X97, X96]) true",
+                "goal_text": "if (var X96) \n (declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n   [X97, X96]) true",
                 "goal_id": 1264
               }
             ],
@@ -23164,8 +22062,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -23205,8 +22102,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "evar X97 (sort (typ «interleave_context.403»)) X96",
+              "goal_text": "evar X97 (sort (typ «interleave_context.403»)) X96",
               "goal_id": 1262
             },
             "cut_branch": {
@@ -23234,8 +22130,7 @@
       "Inference",
       {
         "current_goal_id": 1264,
-        "current_goal_text":
-          "if (var X96) \n (declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n   [X97, X96]) true",
+        "current_goal_text": "if (var X96) \n (declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n   [X97, X96]) true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -23268,8 +22163,7 @@
               { "goal_text": "var X96", "goal_id": 1265 },
               { "goal_text": "!", "goal_id": 1266 },
               {
-                "goal_text":
-                  "declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n [X97, X96]",
+                "goal_text": "declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n [X97, X96]",
                 "goal_id": 1267
               }
             ],
@@ -23301,8 +22195,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -23382,8 +22275,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -23423,8 +22315,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "if (var X96) \n (declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n   [X97, X96]) true",
+              "goal_text": "if (var X96) \n (declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n   [X97, X96]) true",
               "goal_id": 1264
             },
             "cut_branch": {
@@ -23452,8 +22343,7 @@
       "Suspend",
       {
         "suspend_goal_id": 1267,
-        "suspend_goal_text":
-          "declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n [X97, X96]",
+        "suspend_goal_text": "declare_constraint (evar X97 (sort (typ «interleave_context.403»)) X96) \n [X97, X96]",
         "suspend_sibling": {
           "goal_text": "evar X97 (sort (typ «interleave_context.403»)) X96",
           "goal_id": 1268
@@ -23487,8 +22377,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -23554,8 +22443,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
+                "rule_text": "(coq.elaborate-arity-skeleton (arity A0) A1 (arity A2) A3) :- (coq.elaborate-ty-skeleton\n                                                                A0 A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -23574,8 +22462,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -23613,13 +22500,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -23638,8 +22523,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -23664,13 +22548,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -23685,8 +22567,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -23721,13 +22602,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n Definition type illtyped",
+              "goal_text": "std.assert-ok! (coq.elaborate-arity-skeleton (arity X1) _ X69) \n Definition type illtyped",
               "goal_id": 1244
             },
             "cut_branch": {
-              "rule_text":
-                "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
+              "rule_text": "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
               "rule_loc": [
                 "File",
                 {
@@ -23751,8 +22630,7 @@
       "Inference",
       {
         "current_goal_id": 1249,
-        "current_goal_text":
-          "ok = ok ;\n ok = error X93 , std.fatal-error-w-data Definition type illtyped X93",
+        "current_goal_text": "ok = ok ;\n ok = error X93 , std.fatal-error-w-data Definition type illtyped X93",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -23804,8 +22682,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -23843,13 +22720,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -23868,8 +22743,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -23894,13 +22768,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -23915,8 +22787,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -23991,8 +22862,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -24030,13 +22900,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -24055,8 +22923,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -24081,13 +22948,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -24102,8 +22967,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -24138,8 +23002,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "X92 = ok ;\n X92 = error X93 , std.fatal-error-w-data Definition type illtyped X93",
+              "goal_text": "X92 = ok ;\n X92 = error X93 , std.fatal-error-w-data Definition type illtyped X93",
               "goal_id": 1249
             },
             "cut_branch": {
@@ -24173,8 +23036,7 @@
       "Inference",
       {
         "current_goal_id": 1246,
-        "current_goal_text":
-          "std.do!\n [coq.arity->term (arity (X96)) X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (arity (X96) = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity (arity (X96)) [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (arity (X96) = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [coq.arity->term (arity (X96)) X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (arity (X96) = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity (arity (X96)) [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (arity (X96) = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -24183,8 +23045,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -24211,8 +23072,7 @@
               },
               { "goal_text": "!", "goal_id": 1271 },
               {
-                "goal_text":
-                  "std.do!\n [std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (arity (X96) = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity (arity (X96)) [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (arity (X96) = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \n  if (arity (X96) = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity (arity (X96)) [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (arity (X96) = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1272
               }
             ],
@@ -24263,13 +23123,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -24288,8 +23146,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -24314,13 +23171,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -24335,8 +23190,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -24390,8 +23244,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := X96" ],
-                [ "Assign", "X70 := X96" ]
+                [ "Assign", "A0 := X96" ], [ "Assign", "X70 := X96" ]
               ]
             },
             "siblings": [],
@@ -24461,13 +23314,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -24486,8 +23337,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -24512,13 +23362,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -24533,8 +23381,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -24572,8 +23419,7 @@
       "Inference",
       {
         "current_goal_id": 1272,
-        "current_goal_text":
-          "std.do!\n [std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71) \n   Definition illtyped, \n  if (arity (X96) = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity (arity (X96)) [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (arity (X96) = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71) \n   Definition illtyped, \n  if (arity (X96) = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity (arity (X96)) [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (arity (X96) = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -24582,8 +23428,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -24608,14 +23453,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.assert-ok!\n (coq.elaborate-skeleton\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71) \n Definition illtyped",
+                "goal_text": "std.assert-ok!\n (coq.elaborate-skeleton\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71) \n Definition illtyped",
                 "goal_id": 1273
               },
               { "goal_text": "!", "goal_id": 1274 },
               {
-                "goal_text":
-                  "std.do!\n [if (arity (X96) = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity (arity (X96)) [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (arity (X96) = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [if (arity (X96) = arity X72) \n   (if-verbose (coq.say HB: skipping section opening) , X73 = X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity (arity (X96)) [] X71 X73 X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (arity (X96) = arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1275
               }
             ],
@@ -24685,13 +23528,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -24710,8 +23551,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -24736,13 +23576,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -24757,8 +23595,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -24790,8 +23627,7 @@
       "Inference",
       {
         "current_goal_id": 1273,
-        "current_goal_text":
-          "std.assert-ok!\n (coq.elaborate-skeleton\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71) \n Definition illtyped",
+        "current_goal_text": "std.assert-ok!\n (coq.elaborate-skeleton\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71) \n Definition illtyped",
         "current_goal_predicate": "std.assert-ok!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -24800,8 +23636,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                  "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -24823,14 +23658,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.elaborate-skeleton\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71 X98",
+                "goal_text": "coq.elaborate-skeleton\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71 X98",
                 "goal_id": 1276
               },
               { "goal_text": "!", "goal_id": 1277 },
               {
-                "goal_text":
-                  "X98 = ok ; X98 = error X99 , std.fatal-error-w-data Definition illtyped X99",
+                "goal_text": "X98 = ok ; X98 = error X99 , std.fatal-error-w-data Definition illtyped X99",
                 "goal_id": 1278
               },
               { "goal_text": "!", "goal_id": 1279 }
@@ -24844,8 +23677,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -24921,13 +23753,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -24946,8 +23776,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -24972,13 +23801,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -24993,8 +23820,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -25026,8 +23852,7 @@
       "Inference",
       {
         "current_goal_id": 1276,
-        "current_goal_text":
-          "coq.elaborate-skeleton\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71 X98",
+        "current_goal_text": "coq.elaborate-skeleton\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71 X98",
         "current_goal_predicate": "coq.elaborate-skeleton",
         "failed_attempts": [],
         "successful_attempts": [
@@ -25038,13 +23863,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X96 = app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]",
+                "goal_text": "X96 = app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]",
                 "goal_id": 1280
               },
               {
-                "goal_text":
-                  "X71 =\n app\n  [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n   global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
+                "goal_text": "X71 =\n app\n  [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n   global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
                 "goal_id": 1281
               },
               { "goal_text": "X98 = ok", "goal_id": 1282 }
@@ -25063,8 +23886,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -25140,13 +23962,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -25165,8 +23985,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -25191,13 +24010,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -25212,8 +24029,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -25245,8 +24061,7 @@
       "Inference",
       {
         "current_goal_id": 1280,
-        "current_goal_text":
-          "X96 = app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]",
+        "current_goal_text": "X96 = app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -25281,8 +24096,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -25358,13 +24172,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -25383,8 +24195,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -25409,13 +24220,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -25430,8 +24239,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -25463,8 +24271,7 @@
       "Resume",
       [
         {
-          "goal_text":
-            "evar X97 (sort (typ «interleave_context.403»)) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+          "goal_text": "evar X97 (sort (typ «interleave_context.403»)) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
           "goal_id": 1268
         }
       ]
@@ -25478,8 +24285,7 @@
       "Inference",
       {
         "current_goal_id": 1268,
-        "current_goal_text":
-          "evar X97 (sort (typ «interleave_context.403»)) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+        "current_goal_text": "evar X97 (sort (typ «interleave_context.403»)) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
         "current_goal_predicate": "evar",
         "failed_attempts": [],
         "successful_attempts": [
@@ -25488,8 +24294,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                  "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                   "rule_loc": [
                     "File",
                     {
@@ -25513,8 +24318,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1283 },
               {
-                "goal_text":
-                  "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (declare_constraint\n   (evar X97 (sort (typ «interleave_context.403»)) \n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   [X97, app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]]) \n true",
+                "goal_text": "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (declare_constraint\n   (evar X97 (sort (typ «interleave_context.403»)) \n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   [X97, app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]]) \n true",
                 "goal_id": 1284
               }
             ],
@@ -25527,8 +24331,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -25576,8 +24379,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -25617,8 +24419,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "evar X97 (sort (typ «interleave_context.403»)) X96",
+              "goal_text": "evar X97 (sort (typ «interleave_context.403»)) X96",
               "goal_id": 1268
             },
             "cut_branch": {
@@ -25646,8 +24447,7 @@
       "Inference",
       {
         "current_goal_id": 1284,
-        "current_goal_text":
-          "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (declare_constraint\n   (evar X97 (sort (typ «interleave_context.403»)) \n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   [X97, app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]]) \n true",
+        "current_goal_text": "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (declare_constraint\n   (evar X97 (sort (typ «interleave_context.403»)) \n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   [X97, app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]]) \n true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -25681,14 +24481,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+                "goal_text": "var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
                 "goal_id": 1285
               },
               { "goal_text": "!", "goal_id": 1286 },
               {
-                "goal_text":
-                  "declare_constraint\n (evar X97 (sort (typ «interleave_context.403»)) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n [X97, app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]]",
+                "goal_text": "declare_constraint\n (evar X97 (sort (typ «interleave_context.403»)) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n [X97, app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]]",
                 "goal_id": 1287
               }
             ],
@@ -25720,8 +24518,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -25769,8 +24566,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -25807,8 +24603,7 @@
       "Inference",
       {
         "current_goal_id": 1285,
-        "current_goal_text":
-          "var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+        "current_goal_text": "var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
         "current_goal_predicate": "var",
         "failed_attempts": [
           { "rule": [ "BuiltinRule", [ "FFI", "var" ] ], "events": [] }
@@ -25844,8 +24639,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -25893,8 +24687,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -25931,8 +24724,7 @@
       "Inference",
       {
         "current_goal_id": 1284,
-        "current_goal_text":
-          "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (declare_constraint\n   (evar X97 (sort (typ «interleave_context.403»)) \n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   [X97, app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]]) \n true",
+        "current_goal_text": "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (declare_constraint\n   (evar X97 (sort (typ «interleave_context.403»)) \n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   [X97, app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]]) \n true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -25984,8 +24776,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -26033,8 +24824,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -26142,8 +24932,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -26191,8 +24980,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
+                "rule_text": "(evar (as uvar A0) A1 A2) :- (!), \n (if (var A2) (declare_constraint (evar A0 A1 A2) [A0, A2]) true).",
                 "rule_loc": [
                   "File",
                   {
@@ -26229,8 +25017,7 @@
       "Inference",
       {
         "current_goal_id": 1281,
-        "current_goal_text":
-          "X71 =\n app\n  [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n   global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
+        "current_goal_text": "X71 =\n app\n  [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n   global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -26264,8 +25051,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -26341,13 +25127,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -26366,8 +25150,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -26392,13 +25175,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -26413,8 +25194,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -26475,8 +25255,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -26552,13 +25331,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -26577,8 +25354,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -26603,13 +25379,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -26624,8 +25398,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -26660,13 +25433,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.assert-ok!\n (coq.elaborate-skeleton\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71) \n Definition illtyped",
+              "goal_text": "std.assert-ok!\n (coq.elaborate-skeleton\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` X0 c0 \\ c0]) (X96) X71) \n Definition illtyped",
               "goal_id": 1273
             },
             "cut_branch": {
-              "rule_text":
-                "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
+              "rule_text": "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
               "rule_loc": [
                 "File",
                 {
@@ -26690,8 +25461,7 @@
       "Inference",
       {
         "current_goal_id": 1278,
-        "current_goal_text":
-          "ok = ok ; ok = error X99 , std.fatal-error-w-data Definition illtyped X99",
+        "current_goal_text": "ok = ok ; ok = error X99 , std.fatal-error-w-data Definition illtyped X99",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -26743,8 +25513,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -26820,13 +25589,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -26845,8 +25612,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -26871,13 +25637,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -26892,8 +25656,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -26968,8 +25731,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -27045,13 +25807,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -27070,8 +25830,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -27096,13 +25855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -27117,8 +25874,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -27153,8 +25909,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "X98 = ok ; X98 = error X99 , std.fatal-error-w-data Definition illtyped X99",
+              "goal_text": "X98 = ok ; X98 = error X99 , std.fatal-error-w-data Definition illtyped X99",
               "goal_id": 1278
             },
             "cut_branch": {
@@ -27188,8 +25943,7 @@
       "Inference",
       {
         "current_goal_id": 1275,
-        "current_goal_text":
-          "std.do!\n [if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity X72) \n   (if-verbose (coq.say HB: skipping section opening) ,\n     X73 =\n      app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity\n       (arity\n         (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n       [] \n       (app\n         [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n          global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X73 \n       X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity X72) \n   (if-verbose (coq.say HB: skipping section opening) ,\n     X73 =\n      app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (,\n     (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-section X76) \n     (instance.private.postulate-arity\n       (arity\n         (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n       [] \n       (app\n         [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n          global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X73 \n       X72)), \n  std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -27198,8 +25952,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -27224,14 +25977,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if\n (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n   arity X72) \n (if-verbose (coq.say HB: skipping section opening) ,\n   X73 =\n    app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (, (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n   (log.coq.env.begin-section X76) \n   (instance.private.postulate-arity\n     (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n     [] \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X73 \n     X72))",
+                "goal_text": "if\n (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n   arity X72) \n (if-verbose (coq.say HB: skipping section opening) ,\n   X73 =\n    app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (, (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n   (log.coq.env.begin-section X76) \n   (instance.private.postulate-arity\n     (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n     [] \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X73 \n     X72))",
                 "goal_id": 1290
               },
               { "goal_text": "!", "goal_id": 1291 },
               {
-                "goal_text":
-                  "std.do!\n [std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [std.assert! (coq.safe-dest-app X72 (global X77) X78) \n   The type of the instance is not a factory, factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1292
               }
             ],
@@ -27320,13 +26071,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -27345,8 +26094,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -27371,13 +26119,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -27392,8 +26138,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -27425,8 +26170,7 @@
       "Inference",
       {
         "current_goal_id": 1290,
-        "current_goal_text":
-          "if\n (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n   arity X72) \n (if-verbose (coq.say HB: skipping section opening) ,\n   X73 =\n    app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (, (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n   (log.coq.env.begin-section X76) \n   (instance.private.postulate-arity\n     (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n     [] \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X73 \n     X72))",
+        "current_goal_text": "if\n (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n   arity X72) \n (if-verbose (coq.say HB: skipping section opening) ,\n   X73 =\n    app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (, (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n   (log.coq.env.begin-section X76) \n   (instance.private.postulate-arity\n     (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n     [] \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X73 \n     X72))",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -27460,14 +26204,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n arity X72",
+                "goal_text": "arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n arity X72",
                 "goal_id": 1293
               },
               { "goal_text": "!", "goal_id": 1294 },
               {
-                "goal_text":
-                  "if-verbose (coq.say HB: skipping section opening) ,\n X73 =\n  app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
+                "goal_text": "if-verbose (coq.say HB: skipping section opening) ,\n X73 =\n  app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
                 "goal_id": 1295
               }
             ],
@@ -27575,13 +26317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -27600,8 +26340,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -27626,13 +26365,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -27647,8 +26384,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -27680,8 +26416,7 @@
       "Inference",
       {
         "current_goal_id": 1293,
-        "current_goal_text":
-          "arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n arity X72",
+        "current_goal_text": "arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n arity X72",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -27805,13 +26540,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -27830,8 +26563,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -27856,13 +26588,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -27877,8 +26607,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -27913,8 +26642,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "if\n (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n   arity X72) \n (if-verbose (coq.say HB: skipping section opening) ,\n   X73 =\n    app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (, (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n   (log.coq.env.begin-section X76) \n   (instance.private.postulate-arity\n     (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n     [] \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X73 \n     X72))",
+              "goal_text": "if\n (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n   arity X72) \n (if-verbose (coq.say HB: skipping section opening) ,\n   X73 =\n    app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (, (, (new_int X74) (std.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n   (log.coq.env.begin-section X76) \n   (instance.private.postulate-arity\n     (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n     [] \n     (app\n       [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X73 \n     X72))",
               "goal_id": 1290
             },
             "cut_branch": {
@@ -27942,8 +26670,7 @@
       "Inference",
       {
         "current_goal_id": 1295,
-        "current_goal_text":
-          "if-verbose (coq.say HB: skipping section opening) ,\n X73 =\n  app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
+        "current_goal_text": "if-verbose (coq.say HB: skipping section opening) ,\n X73 =\n  app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
         "current_goal_predicate": ",",
         "failed_attempts": [],
         "successful_attempts": [
@@ -27954,13 +26681,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if-verbose (coq.say HB: skipping section opening)",
+                "goal_text": "if-verbose (coq.say HB: skipping section opening)",
                 "goal_id": 1296
               },
               {
-                "goal_text":
-                  "X73 =\n app\n  [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n   global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
+                "goal_text": "X73 =\n app\n  [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n   global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
                 "goal_id": 1297
               }
             ],
@@ -28073,13 +26798,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -28098,8 +26821,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -28124,13 +26846,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -28145,8 +26865,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -28178,8 +26897,7 @@
       "Inference",
       {
         "current_goal_id": 1296,
-        "current_goal_text":
-          "if-verbose (coq.say HB: skipping section opening)",
+        "current_goal_text": "if-verbose (coq.say HB: skipping section opening)",
         "current_goal_predicate": "if-verbose",
         "failed_attempts": [],
         "successful_attempts": [
@@ -28188,13 +26906,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(if-verbose A0) :- (get-option verbose tt), (!), A0.",
+                  "rule_text": "(if-verbose A0) :- (get-option verbose tt), (!), A0.",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 51,
                       "column": 0,
                       "character": 1529
@@ -28223,13 +26939,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(if-verbose A0) :- (get-option verbose tt), (!), A0.",
+                "rule_text": "(if-verbose A0) :- (get-option verbose tt), (!), A0.",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 51,
                     "column": 0,
                     "character": 1529
@@ -28344,13 +27058,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -28369,8 +27081,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -28395,13 +27106,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -28416,8 +27125,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -28459,13 +27167,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(if-verbose A0) :- (get-option verbose tt), (!), A0.",
+                "rule_text": "(if-verbose A0) :- (get-option verbose tt), (!), A0.",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 51,
                     "column": 0,
                     "character": 1529
@@ -28580,13 +27286,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -28605,8 +27309,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -28631,13 +27334,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -28652,8 +27353,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -28685,8 +27385,7 @@
       "Inference",
       {
         "current_goal_id": 1296,
-        "current_goal_text":
-          "if-verbose (coq.say HB: skipping section opening)",
+        "current_goal_text": "if-verbose (coq.say HB: skipping section opening)",
         "current_goal_predicate": "if-verbose",
         "failed_attempts": [],
         "successful_attempts": [
@@ -28699,8 +27398,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 52,
                       "column": 0,
                       "character": 1576
@@ -28724,8 +27422,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 52,
                     "column": 0,
                     "character": 1576
@@ -28840,13 +27537,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -28865,8 +27560,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -28891,13 +27585,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -28912,8 +27604,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -28945,8 +27636,7 @@
       "Inference",
       {
         "current_goal_id": 1297,
-        "current_goal_text":
-          "X73 =\n app\n  [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n   global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
+        "current_goal_text": "X73 =\n app\n  [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n   global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -29075,13 +27765,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -29100,8 +27788,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -29126,13 +27813,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -29147,8 +27832,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -29186,8 +27870,7 @@
       "Inference",
       {
         "current_goal_id": 1292,
-        "current_goal_text":
-          "std.do!\n [std.assert!\n   (coq.safe-dest-app\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n     (global X77) X78) The type of the instance is not a factory, \n  factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [std.assert!\n   (coq.safe-dest-app\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n     (global X77) X78) The type of the instance is not a factory, \n  factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -29196,8 +27879,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -29222,14 +27904,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.assert!\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global X77) X78) The type of the instance is not a factory",
+                "goal_text": "std.assert!\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global X77) X78) The type of the instance is not a factory",
                 "goal_id": 1301
               },
               { "goal_text": "!", "goal_id": 1302 },
               {
-                "goal_text":
-                  "std.do!\n [factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [factory-alias->gref X77 X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1303
               }
             ],
@@ -29337,13 +28017,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -29362,8 +28040,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -29388,13 +28065,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -29409,8 +28084,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -29442,8 +28116,7 @@
       "Inference",
       {
         "current_goal_id": 1301,
-        "current_goal_text":
-          "std.assert!\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global X77) X78) The type of the instance is not a factory",
+        "current_goal_text": "std.assert!\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global X77) X78) The type of the instance is not a factory",
         "current_goal_predicate": "std.assert!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -29452,8 +28125,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                  "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -29477,8 +28149,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78 ;\n std.fatal-error-w-data The type of the instance is not a factory \n  (coq.safe-dest-app\n    (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n    (global X77) X78)",
+                "goal_text": "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78 ;\n std.fatal-error-w-data The type of the instance is not a factory \n  (coq.safe-dest-app\n    (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n    (global X77) X78)",
                 "goal_id": 1304
               },
               { "goal_text": "!", "goal_id": 1305 }
@@ -29492,8 +28163,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -29607,13 +28277,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -29632,8 +28300,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -29658,13 +28325,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -29679,8 +28344,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -29712,8 +28376,7 @@
       "Inference",
       {
         "current_goal_id": 1304,
-        "current_goal_text":
-          "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78 ;\n std.fatal-error-w-data The type of the instance is not a factory \n  (coq.safe-dest-app\n    (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n    (global X77) X78)",
+        "current_goal_text": "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78 ;\n std.fatal-error-w-data The type of the instance is not a factory \n  (coq.safe-dest-app\n    (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n    (global X77) X78)",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -29743,8 +28406,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78",
+                "goal_text": "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78",
                 "goal_id": 1306
               }
             ],
@@ -29776,8 +28438,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -29891,13 +28552,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -29916,8 +28575,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -29942,13 +28600,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -29963,8 +28619,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -29996,8 +28651,7 @@
       "Inference",
       {
         "current_goal_id": 1306,
-        "current_goal_text":
-          "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78",
+        "current_goal_text": "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78",
         "current_goal_predicate": "coq.safe-dest-app",
         "failed_attempts": [],
         "successful_attempts": [
@@ -30006,8 +28660,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
+                  "rule_text": "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
                   "rule_loc": [
                     "File",
                     {
@@ -30029,8 +28682,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1307 },
               {
-                "goal_text":
-                  "coq.safe-dest-app (global (indt «IsSelfA'.axioms_»)) (global X77) X100",
+                "goal_text": "coq.safe-dest-app (global (indt «IsSelfA'.axioms_»)) (global X77) X100",
                 "goal_id": 1308
               },
               {
@@ -30047,8 +28699,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
+                "rule_text": "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -30086,8 +28737,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -30201,13 +28851,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -30226,8 +28874,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -30252,13 +28899,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -30273,8 +28918,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -30309,8 +28953,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78",
+              "goal_text": "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78",
               "goal_id": 1306
             },
             "cut_branch": {
@@ -30338,8 +28981,7 @@
       "Inference",
       {
         "current_goal_id": 1308,
-        "current_goal_text":
-          "coq.safe-dest-app (global (indt «IsSelfA'.axioms_»)) (global X77) X100",
+        "current_goal_text": "coq.safe-dest-app (global (indt «IsSelfA'.axioms_»)) (global X77) X100",
         "current_goal_predicate": "coq.safe-dest-app",
         "failed_attempts": [],
         "successful_attempts": [
@@ -30395,8 +29037,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
+                "rule_text": "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -30434,8 +29075,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -30549,13 +29189,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -30574,8 +29212,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -30600,13 +29237,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -30621,8 +29256,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -30709,8 +29343,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
+                "rule_text": "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -30748,8 +29381,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -30863,13 +29495,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -30888,8 +29518,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -30914,13 +29543,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -30935,8 +29562,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -30971,8 +29597,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78 ;\n std.fatal-error-w-data The type of the instance is not a factory \n  (coq.safe-dest-app\n    (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n    (global X77) X78)",
+              "goal_text": "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global X77) X78 ;\n std.fatal-error-w-data The type of the instance is not a factory \n  (coq.safe-dest-app\n    (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n    (global X77) X78)",
               "goal_id": 1304
             },
             "cut_branch": {
@@ -31006,8 +29631,7 @@
       "Inference",
       {
         "current_goal_id": 1303,
-        "current_goal_text":
-          "std.do!\n [factory-alias->gref (indt «IsSelfA'.axioms_») X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [factory-alias->gref (indt «IsSelfA'.axioms_») X79, \n  std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -31016,8 +29640,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -31042,14 +29665,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
+                "goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
                 "goal_id": 1310
               },
               { "goal_text": "!", "goal_id": 1311 },
               {
-                "goal_text":
-                  "std.do!\n [std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [std.assert! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1312
               }
             ],
@@ -31176,13 +29797,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -31201,8 +29820,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -31227,13 +29845,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -31248,8 +29864,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -31281,8 +29896,7 @@
       "Inference",
       {
         "current_goal_id": 1310,
-        "current_goal_text":
-          "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
+        "current_goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
         "current_goal_predicate": "factory-alias->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -31291,13 +29905,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                  "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 74,
                       "column": 0,
                       "character": 2385
@@ -31326,13 +29938,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 74,
                     "column": 0,
                     "character": 2385
@@ -31461,13 +30071,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -31486,8 +30094,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -31512,13 +30119,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -31533,8 +30138,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -31573,8 +30177,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -31598,8 +30201,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -31623,8 +30225,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -31648,8 +30249,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -31673,8 +30273,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -31698,8 +30297,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -31723,8 +30321,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -31748,8 +30345,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -31777,8 +30373,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -31797,13 +30392,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 74,
                     "column": 0,
                     "character": 2385
@@ -31932,13 +30525,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -31957,8 +30548,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -31983,13 +30573,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -32004,8 +30592,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -32037,8 +30624,7 @@
       "Inference",
       {
         "current_goal_id": 1310,
-        "current_goal_text":
-          "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
+        "current_goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
         "current_goal_predicate": "factory-alias->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -32047,13 +30633,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                  "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 75,
                       "column": 0,
                       "character": 2443
@@ -32082,13 +30666,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2443
@@ -32217,13 +30799,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -32242,8 +30822,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -32268,13 +30847,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -32289,8 +30866,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -32329,8 +30905,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -32353,8 +30928,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -32377,8 +30951,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -32399,8 +30972,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                  "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                   "rule_loc": [
                     "File",
                     {
@@ -32429,8 +31001,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -32449,13 +31020,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2443
@@ -32584,13 +31153,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -32609,8 +31176,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -32635,13 +31201,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -32656,8 +31220,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -32692,13 +31255,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
+              "goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
               "goal_id": 1310
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «A.axioms_») (indt «A.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «A.axioms_») (indt «A.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -32712,13 +31273,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
+              "goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
               "goal_id": 1310
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «B.axioms_») (indt «B.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «B.axioms_») (indt «B.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -32732,13 +31291,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
+              "goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X79",
               "goal_id": 1310
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «SelfA.axioms_») (indt «SelfA.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «SelfA.axioms_») (indt «SelfA.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -32768,8 +31325,7 @@
       "Inference",
       {
         "current_goal_id": 1312,
-        "current_goal_text":
-          "std.do!\n [std.assert! (factory-nparams (indt «IsSelfA'.axioms_») X80) \n   Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [std.assert! (factory-nparams (indt «IsSelfA'.axioms_») X80) \n   Not a factory synthesized by HB, \n  instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -32778,8 +31334,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -32804,14 +31359,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.assert! (factory-nparams (indt «IsSelfA'.axioms_») X80) \n Not a factory synthesized by HB",
+                "goal_text": "std.assert! (factory-nparams (indt «IsSelfA'.axioms_») X80) \n Not a factory synthesized by HB",
                 "goal_id": 1317
               },
               { "goal_text": "!", "goal_id": 1318 },
               {
-                "goal_text":
-                  "std.do!\n [instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop X80 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1319
               }
             ],
@@ -32957,13 +31510,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -32982,8 +31533,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -33008,13 +31558,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -33029,8 +31577,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -33062,8 +31609,7 @@
       "Inference",
       {
         "current_goal_id": 1317,
-        "current_goal_text":
-          "std.assert! (factory-nparams (indt «IsSelfA'.axioms_») X80) \n Not a factory synthesized by HB",
+        "current_goal_text": "std.assert! (factory-nparams (indt «IsSelfA'.axioms_») X80) \n Not a factory synthesized by HB",
         "current_goal_predicate": "std.assert!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -33072,8 +31618,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                  "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -33095,8 +31640,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "factory-nparams (indt «IsSelfA'.axioms_») X80 ;\n std.fatal-error-w-data Not a factory synthesized by HB \n  (factory-nparams (indt «IsSelfA'.axioms_») X80)",
+                "goal_text": "factory-nparams (indt «IsSelfA'.axioms_») X80 ;\n std.fatal-error-w-data Not a factory synthesized by HB \n  (factory-nparams (indt «IsSelfA'.axioms_») X80)",
                 "goal_id": 1320
               },
               { "goal_text": "!", "goal_id": 1321 }
@@ -33110,8 +31654,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -33263,13 +31806,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -33288,8 +31829,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -33314,13 +31854,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -33335,8 +31873,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -33368,8 +31905,7 @@
       "Inference",
       {
         "current_goal_id": 1320,
-        "current_goal_text":
-          "factory-nparams (indt «IsSelfA'.axioms_») X80 ;\n std.fatal-error-w-data Not a factory synthesized by HB \n  (factory-nparams (indt «IsSelfA'.axioms_») X80)",
+        "current_goal_text": "factory-nparams (indt «IsSelfA'.axioms_») X80 ;\n std.fatal-error-w-data Not a factory synthesized by HB \n  (factory-nparams (indt «IsSelfA'.axioms_») X80)",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -33399,8 +31935,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "factory-nparams (indt «IsSelfA'.axioms_») X80",
+                "goal_text": "factory-nparams (indt «IsSelfA'.axioms_») X80",
                 "goal_id": 1322
               }
             ],
@@ -33432,8 +31967,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -33585,13 +32119,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -33610,8 +32142,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -33636,13 +32167,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -33657,8 +32186,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -33690,8 +32218,7 @@
       "Inference",
       {
         "current_goal_id": 1322,
-        "current_goal_text":
-          "factory-nparams (indt «IsSelfA'.axioms_») X80",
+        "current_goal_text": "factory-nparams (indt «IsSelfA'.axioms_») X80",
         "current_goal_predicate": "factory-nparams",
         "failed_attempts": [
           {
@@ -33721,8 +32248,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «HasB.axioms_») 1) :- .",
+                "rule_text": "(factory-nparams (indt «HasB.axioms_») 1) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -33768,8 +32294,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «IsSelfA.axioms_») 0) :- .",
+                "rule_text": "(factory-nparams (indt «IsSelfA.axioms_») 0) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -33792,8 +32317,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «SelfA.axioms_») 0) :- .",
+                "rule_text": "(factory-nparams (indt «SelfA.axioms_») 0) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -33816,8 +32340,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «IsSelfA'.axioms_») 0) :- .",
+                "rule_text": "(factory-nparams (indt «IsSelfA'.axioms_») 0) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -33838,8 +32361,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-nparams (indt «HasA.axioms_») 1) :- .",
+                  "rule_text": "(factory-nparams (indt «HasA.axioms_») 1) :- .",
                   "rule_loc": [
                     "File",
                     {
@@ -33868,8 +32390,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «HasA.axioms_») 1) :- .",
+                "rule_text": "(factory-nparams (indt «HasA.axioms_») 1) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -33907,8 +32428,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -34060,13 +32580,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -34085,8 +32603,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -34111,13 +32628,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -34132,8 +32647,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -34168,8 +32682,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-nparams (indt «IsSelfA'.axioms_») X80 ;\n std.fatal-error-w-data Not a factory synthesized by HB \n  (factory-nparams (indt «IsSelfA'.axioms_») X80)",
+              "goal_text": "factory-nparams (indt «IsSelfA'.axioms_») X80 ;\n std.fatal-error-w-data Not a factory synthesized by HB \n  (factory-nparams (indt «IsSelfA'.axioms_») X80)",
               "goal_id": 1320
             },
             "cut_branch": {
@@ -34203,8 +32716,7 @@
       "Inference",
       {
         "current_goal_id": 1319,
-        "current_goal_text":
-          "std.do!\n [instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [instance.private.hack-section-discharging\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81, \n  instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -34213,8 +32725,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -34239,14 +32750,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "instance.private.hack-section-discharging\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81",
+                "goal_text": "instance.private.hack-section-discharging\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81",
                 "goal_id": 1323
               },
               { "goal_text": "!", "goal_id": 1324 },
               {
-                "goal_text":
-                  "std.do!\n [instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [instance.private.optimize-body X81 X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1325
               }
             ],
@@ -34411,13 +32920,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -34436,8 +32943,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -34462,13 +32968,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -34483,8 +32987,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -34516,8 +33019,7 @@
       "Inference",
       {
         "current_goal_id": 1323,
-        "current_goal_text":
-          "instance.private.hack-section-discharging\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81",
+        "current_goal_text": "instance.private.hack-section-discharging\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81",
         "current_goal_predicate": "instance.private.hack-section-discharging",
         "failed_attempts": [],
         "successful_attempts": [
@@ -34526,13 +33028,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.private.hack-section-discharging A0 A0) :- (current-mode no-builder), \n (!).",
+                  "rule_text": "(instance.private.hack-section-discharging A0 A0) :- (current-mode no-builder), \n (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 300,
                       "column": 0,
                       "character": 12925
@@ -34564,13 +33064,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.hack-section-discharging A0 A0) :- (current-mode no-builder), \n (!).",
+                "rule_text": "(instance.private.hack-section-discharging A0 A0) :- (current-mode no-builder), \n (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 300,
                     "column": 0,
                     "character": 12925
@@ -34737,13 +33235,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -34762,8 +33258,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -34788,13 +33283,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -34809,8 +33302,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -34852,13 +33344,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.hack-section-discharging A0 A0) :- (current-mode no-builder), \n (!).",
+                "rule_text": "(instance.private.hack-section-discharging A0 A0) :- (current-mode no-builder), \n (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 300,
                     "column": 0,
                     "character": 12925
@@ -35025,13 +33515,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -35050,8 +33538,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -35076,13 +33563,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -35097,8 +33582,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -35130,8 +33614,7 @@
       "Inference",
       {
         "current_goal_id": 1323,
-        "current_goal_text":
-          "instance.private.hack-section-discharging\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81",
+        "current_goal_text": "instance.private.hack-section-discharging\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81",
         "current_goal_predicate": "instance.private.hack-section-discharging",
         "failed_attempts": [],
         "successful_attempts": [
@@ -35140,13 +33623,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.private.hack-section-discharging A0 A1) :- (current-mode\n                                                       (builder-from _ A2 _ _)), \n (!), (std.assert-ok! (coq.typecheck A2 A3) TheFactory is illtyped (BUG)), \n (A1 = let `_` A3 A2 (c0 \\ A0)).",
+                  "rule_text": "(instance.private.hack-section-discharging A0 A1) :- (current-mode\n                                                       (builder-from _ A2 _ _)), \n (!), (std.assert-ok! (coq.typecheck A2 A3) TheFactory is illtyped (BUG)), \n (A1 = let `_` A3 A2 (c0 \\ A0)).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 301,
                       "column": 0,
                       "character": 12985
@@ -35169,13 +33650,11 @@
               },
               { "goal_text": "!", "goal_id": 1329 },
               {
-                "goal_text":
-                  "std.assert-ok! (coq.typecheck X101 X102) TheFactory is illtyped (BUG)",
+                "goal_text": "std.assert-ok! (coq.typecheck X101 X102) TheFactory is illtyped (BUG)",
                 "goal_id": 1330
               },
               {
-                "goal_text":
-                  "X81 =\n let `_` X102 X101 c0 \\\n  app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c1 \\ c1]",
+                "goal_text": "X81 =\n let `_` X102 X101 c0 \\\n  app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c1 \\ c1]",
                 "goal_id": 1331
               }
             ],
@@ -35188,13 +33667,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.hack-section-discharging A0 A1) :- (current-mode\n                                                       (builder-from _ A2 _ _)), \n (!), (std.assert-ok! (coq.typecheck A2 A3) TheFactory is illtyped (BUG)), \n (A1 = let `_` A3 A2 (c0 \\ A0)).",
+                "rule_text": "(instance.private.hack-section-discharging A0 A1) :- (current-mode\n                                                       (builder-from _ A2 _ _)), \n (!), (std.assert-ok! (coq.typecheck A2 A3) TheFactory is illtyped (BUG)), \n (A1 = let `_` A3 A2 (c0 \\ A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 301,
                     "column": 0,
                     "character": 12985
@@ -35361,13 +33838,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -35386,8 +33861,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -35412,13 +33886,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -35433,8 +33905,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -35476,13 +33947,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.hack-section-discharging A0 A1) :- (current-mode\n                                                       (builder-from _ A2 _ _)), \n (!), (std.assert-ok! (coq.typecheck A2 A3) TheFactory is illtyped (BUG)), \n (A1 = let `_` A3 A2 (c0 \\ A0)).",
+                "rule_text": "(instance.private.hack-section-discharging A0 A1) :- (current-mode\n                                                       (builder-from _ A2 _ _)), \n (!), (std.assert-ok! (coq.typecheck A2 A3) TheFactory is illtyped (BUG)), \n (A1 = let `_` A3 A2 (c0 \\ A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 301,
                     "column": 0,
                     "character": 12985
@@ -35649,13 +34118,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -35674,8 +34141,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -35700,13 +34166,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -35721,8 +34185,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -35754,8 +34217,7 @@
       "Inference",
       {
         "current_goal_id": 1323,
-        "current_goal_text":
-          "instance.private.hack-section-discharging\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81",
+        "current_goal_text": "instance.private.hack-section-discharging\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X81",
         "current_goal_predicate": "instance.private.hack-section-discharging",
         "failed_attempts": [],
         "successful_attempts": [
@@ -35764,13 +34226,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.private.hack-section-discharging A0 A0) :- .",
+                  "rule_text": "(instance.private.hack-section-discharging A0 A0) :- .",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 304,
                       "column": 0,
                       "character": 13219
@@ -35799,13 +34259,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.hack-section-discharging A0 A0) :- .",
+                "rule_text": "(instance.private.hack-section-discharging A0 A0) :- .",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 304,
                     "column": 0,
                     "character": 13219
@@ -35972,13 +34430,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -35997,8 +34453,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -36023,13 +34478,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -36044,8 +34497,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -36083,8 +34535,7 @@
       "Inference",
       {
         "current_goal_id": 1325,
-        "current_goal_text":
-          "std.do!\n [instance.private.optimize-body\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [instance.private.optimize-body\n   (app\n     [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X82, \n  if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -36093,8 +34544,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -36119,14 +34569,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "instance.private.optimize-body\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X82",
+                "goal_text": "instance.private.optimize-body\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X82",
                 "goal_id": 1332
               },
               { "goal_text": "!", "goal_id": 1333 },
               {
-                "goal_text":
-                  "std.do!\n [if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 X82 \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1334
               }
             ],
@@ -36310,13 +34758,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -36335,8 +34781,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -36361,13 +34806,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -36382,8 +34825,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -36415,8 +34857,7 @@
       "Inference",
       {
         "current_goal_id": 1332,
-        "current_goal_text":
-          "instance.private.optimize-body\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X82",
+        "current_goal_text": "instance.private.optimize-body\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X82",
         "current_goal_predicate": "instance.private.optimize-body",
         "failed_attempts": [],
         "successful_attempts": [
@@ -36425,13 +34866,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                  "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 309,
                       "column": 0,
                       "character": 13433
@@ -36450,19 +34889,16 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "phant-abbrev _ (const «IsSelfA'.phant_Build») _ ;\n coq.gref->id (const «IsSelfA'.phant_Build») X103 , rex_match phant_ X103",
+                "goal_text": "phant-abbrev _ (const «IsSelfA'.phant_Build») _ ;\n coq.gref->id (const «IsSelfA'.phant_Build») X103 , rex_match phant_ X103",
                 "goal_id": 1335
               },
               { "goal_text": "!", "goal_id": 1336 },
               {
-                "goal_text":
-                  "coq.env.const «IsSelfA'.phant_Build» (some X104) _",
+                "goal_text": "coq.env.const «IsSelfA'.phant_Build» (some X104) _",
                 "goal_id": 1337
               },
               {
-                "goal_text":
-                  "hd-beta X104 \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
+                "goal_text": "hd-beta X104 \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
                 "goal_id": 1338
               },
               { "goal_text": "unwind X105 X106 X82", "goal_id": 1339 }
@@ -36476,13 +34912,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -36668,13 +35102,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -36693,8 +35125,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -36719,13 +35150,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -36740,8 +35169,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -36773,8 +35201,7 @@
       "Inference",
       {
         "current_goal_id": 1335,
-        "current_goal_text":
-          "phant-abbrev _ (const «IsSelfA'.phant_Build») _ ;\n coq.gref->id (const «IsSelfA'.phant_Build») X103 , rex_match phant_ X103",
+        "current_goal_text": "phant-abbrev _ (const «IsSelfA'.phant_Build») _ ;\n coq.gref->id (const «IsSelfA'.phant_Build») X103 , rex_match phant_ X103",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -36804,8 +35231,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "phant-abbrev _ (const «IsSelfA'.phant_Build») _",
+                "goal_text": "phant-abbrev _ (const «IsSelfA'.phant_Build») _",
                 "goal_id": 1340
               }
             ],
@@ -36837,13 +35263,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -37029,13 +35453,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -37054,8 +35476,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -37080,13 +35501,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -37101,8 +35520,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -37134,16 +35552,14 @@
       "Inference",
       {
         "current_goal_id": 1340,
-        "current_goal_text":
-          "phant-abbrev _ (const «IsSelfA'.phant_Build») _",
+        "current_goal_text": "phant-abbrev _ (const «IsSelfA'.phant_Build») _",
         "current_goal_predicate": "phant-abbrev",
         "failed_attempts": [
           {
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -37166,8 +35582,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -37190,8 +35605,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -37214,8 +35628,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -37238,8 +35651,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -37262,8 +35674,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -37286,8 +35697,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -37308,8 +35718,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                  "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                   "rule_loc": [
                     "File",
                     {
@@ -37338,8 +35747,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -37377,13 +35785,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -37569,13 +35975,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -37594,8 +35998,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -37620,13 +36023,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -37641,8 +36042,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -37677,8 +36077,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "phant-abbrev _ (const «IsSelfA'.phant_Build») _ ;\n coq.gref->id (const «IsSelfA'.phant_Build») X103 , rex_match phant_ X103",
+              "goal_text": "phant-abbrev _ (const «IsSelfA'.phant_Build») _ ;\n coq.gref->id (const «IsSelfA'.phant_Build») X103 , rex_match phant_ X103",
               "goal_id": 1335
             },
             "cut_branch": {
@@ -37696,8 +36095,7 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "instance.private.optimize-body\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X82",
+              "goal_text": "instance.private.optimize-body\n (app\n   [global (const «IsSelfA'.phant_Build»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X82",
               "goal_id": 1332
             },
             "cut_branch": {
@@ -37705,8 +36103,7 @@
               "rule_loc": [
                 "File",
                 {
-                  "filename":
-                    "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                  "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                   "line": 314,
                   "column": 0,
                   "character": 13706
@@ -37726,8 +36123,7 @@
       "Inference",
       {
         "current_goal_id": 1337,
-        "current_goal_text":
-          "coq.env.const «IsSelfA'.phant_Build» (some X104) _",
+        "current_goal_text": "coq.env.const «IsSelfA'.phant_Build» (some X104) _",
         "current_goal_predicate": "coq.env.const",
         "failed_attempts": [],
         "successful_attempts": [
@@ -37738,8 +36134,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "some X104 =\n some\n  (fun `TheType` (sort (typ «interleave_context.386»)) c0 \\\n    fun `a` c0 c1 \\\n     fun `b` (prod `_` c0 c2 \\ c0) c2 \\\n      app [global (indc «IsSelfA'.Axioms_»), c0, c1, c2])",
+                "goal_text": "some X104 =\n some\n  (fun `TheType` (sort (typ «interleave_context.386»)) c0 \\\n    fun `a` c0 c1 \\\n     fun `b` (prod `_` c0 c2 \\ c0) c2 \\\n      app [global (indc «IsSelfA'.Axioms_»), c0, c1, c2])",
                 "goal_id": 1341
               }
             ],
@@ -37757,13 +36152,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -37949,13 +36342,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -37974,8 +36365,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -38000,13 +36390,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -38021,8 +36409,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -38054,8 +36441,7 @@
       "Inference",
       {
         "current_goal_id": 1341,
-        "current_goal_text":
-          "some X104 =\n some\n  (fun `TheType` (sort (typ «interleave_context.386»)) c0 \\\n    fun `a` c0 c1 \\\n     fun `b` (prod `_` c0 c2 \\ c0) c2 \\\n      app [global (indc «IsSelfA'.Axioms_»), c0, c1, c2])",
+        "current_goal_text": "some X104 =\n some\n  (fun `TheType` (sort (typ «interleave_context.386»)) c0 \\\n    fun `a` c0 c1 \\\n     fun `b` (prod `_` c0 c2 \\ c0) c2 \\\n      app [global (indc «IsSelfA'.Axioms_»), c0, c1, c2])",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -38089,13 +36475,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -38281,13 +36665,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -38306,8 +36688,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -38332,13 +36713,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -38353,8 +36732,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -38386,8 +36764,7 @@
       "Inference",
       {
         "current_goal_id": 1338,
-        "current_goal_text":
-          "hd-beta\n (fun `TheType` (sort (typ «interleave_context.386»)) c0 \\\n   fun `a` c0 c1 \\\n    fun `b` (prod `_` c0 c2 \\ c0) c2 \\\n     app [global (indc «IsSelfA'.Axioms_»), c0, c1, c2]) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
+        "current_goal_text": "hd-beta\n (fun `TheType` (sort (typ «interleave_context.386»)) c0 \\\n   fun `a` c0 c1 \\\n    fun `b` (prod `_` c0 c2 \\ c0) c2 \\\n     app [global (indc «IsSelfA'.Axioms_»), c0, c1, c2]) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
         "current_goal_predicate": "hd-beta",
         "failed_attempts": [],
         "successful_attempts": [
@@ -38396,8 +36773,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                  "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -38426,8 +36802,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1342 },
               {
-                "goal_text":
-                  "hd-beta\n (fun `a` (global (indt «nat»)) c0 \\\n   fun `b` (prod `_` (global (indt «nat»)) c1 \\ global (indt «nat»)) c1 \\\n    app [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), c0, c1]) \n [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
+                "goal_text": "hd-beta\n (fun `a` (global (indt «nat»)) c0 \\\n   fun `b` (prod `_` (global (indt «nat»)) c1 \\ global (indt «nat»)) c1 \\\n    app [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), c0, c1]) \n [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
                 "goal_id": 1343
               }
             ],
@@ -38440,8 +36815,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -38460,13 +36834,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -38652,13 +37024,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -38677,8 +37047,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -38703,13 +37072,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -38724,8 +37091,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -38760,8 +37126,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "hd-beta X104 \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
+              "goal_text": "hd-beta X104 \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
               "goal_id": 1338
             },
             "cut_branch": {
@@ -38789,8 +37154,7 @@
       "Inference",
       {
         "current_goal_id": 1343,
-        "current_goal_text":
-          "hd-beta\n (fun `a` (global (indt «nat»)) c0 \\\n   fun `b` (prod `_` (global (indt «nat»)) c1 \\ global (indt «nat»)) c1 \\\n    app [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), c0, c1]) \n [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
+        "current_goal_text": "hd-beta\n (fun `a` (global (indt «nat»)) c0 \\\n   fun `b` (prod `_` (global (indt «nat»)) c1 \\ global (indt «nat»)) c1 \\\n    app [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), c0, c1]) \n [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
         "current_goal_predicate": "hd-beta",
         "failed_attempts": [],
         "successful_attempts": [
@@ -38799,8 +37163,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                  "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -38829,8 +37192,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1344 },
               {
-                "goal_text":
-                  "hd-beta\n (fun `b` (prod `_` (global (indt «nat»)) c0 \\ global (indt «nat»)) c0 \\\n   app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), c0]) [fun `x` (global (indt «nat»)) c0 \\ c0] \n X105 X106",
+                "goal_text": "hd-beta\n (fun `b` (prod `_` (global (indt «nat»)) c0 \\ global (indt «nat»)) c0 \\\n   app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), c0]) [fun `x` (global (indt «nat»)) c0 \\ c0] \n X105 X106",
                 "goal_id": 1345
               }
             ],
@@ -38843,8 +37205,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -38863,8 +37224,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -38883,13 +37243,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -39075,13 +37433,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -39100,8 +37456,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -39126,13 +37481,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -39147,8 +37500,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -39183,8 +37535,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "hd-beta\n (fun `a` (global (indt «nat»)) c0 \\\n   fun `b` (prod `_` (global (indt «nat»)) c1 \\ global (indt «nat»)) c1 \\\n    app [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), c0, c1]) \n [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
+              "goal_text": "hd-beta\n (fun `a` (global (indt «nat»)) c0 \\\n   fun `b` (prod `_` (global (indt «nat»)) c1 \\ global (indt «nat»)) c1 \\\n    app [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), c0, c1]) \n [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
               "goal_id": 1343
             },
             "cut_branch": {
@@ -39212,8 +37563,7 @@
       "Inference",
       {
         "current_goal_id": 1345,
-        "current_goal_text":
-          "hd-beta\n (fun `b` (prod `_` (global (indt «nat»)) c0 \\ global (indt «nat»)) c0 \\\n   app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), c0]) [fun `x` (global (indt «nat»)) c0 \\ c0] \n X105 X106",
+        "current_goal_text": "hd-beta\n (fun `b` (prod `_` (global (indt «nat»)) c0 \\ global (indt «nat»)) c0 \\\n   app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), c0]) [fun `x` (global (indt «nat»)) c0 \\ c0] \n X105 X106",
         "current_goal_predicate": "hd-beta",
         "failed_attempts": [],
         "successful_attempts": [
@@ -39222,8 +37572,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                  "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -39251,8 +37600,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1346 },
               {
-                "goal_text":
-                  "hd-beta\n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) [] X105 \n X106",
+                "goal_text": "hd-beta\n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) [] X105 \n X106",
                 "goal_id": 1347
               }
             ],
@@ -39265,8 +37613,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -39285,8 +37632,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -39305,8 +37651,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -39325,13 +37670,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -39517,13 +37860,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -39542,8 +37883,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -39568,13 +37908,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -39589,8 +37927,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -39625,8 +37962,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "hd-beta\n (fun `b` (prod `_` (global (indt «nat»)) c0 \\ global (indt «nat»)) c0 \\\n   app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), c0]) [fun `x` (global (indt «nat»)) c0 \\ c0] \n X105 X106",
+              "goal_text": "hd-beta\n (fun `b` (prod `_` (global (indt «nat»)) c0 \\ global (indt «nat»)) c0 \\\n   app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), c0]) [fun `x` (global (indt «nat»)) c0 \\ c0] \n X105 X106",
               "goal_id": 1345
             },
             "cut_branch": {
@@ -39654,8 +37990,7 @@
       "Inference",
       {
         "current_goal_id": 1347,
-        "current_goal_text":
-          "hd-beta\n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) [] X105 \n X106",
+        "current_goal_text": "hd-beta\n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) [] X105 \n X106",
         "current_goal_predicate": "hd-beta",
         "failed_attempts": [],
         "successful_attempts": [
@@ -39664,8 +37999,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
+                  "rule_text": "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -39691,13 +38025,11 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1348 },
               {
-                "goal_text":
-                  "std.append\n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] [] X107",
+                "goal_text": "std.append\n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] [] X107",
                 "goal_id": 1349
               },
               {
-                "goal_text":
-                  "hd-beta (global (indc «IsSelfA'.Axioms_»)) X107 X105 X106",
+                "goal_text": "hd-beta (global (indc «IsSelfA'.Axioms_»)) X107 X105 X106",
                 "goal_id": 1350
               }
             ],
@@ -39710,8 +38042,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
+                "rule_text": "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -39730,8 +38061,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -39750,8 +38080,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -39770,8 +38099,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -39790,13 +38118,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -39982,13 +38308,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -40007,8 +38331,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -40033,13 +38356,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -40054,8 +38375,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -40090,8 +38410,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "hd-beta\n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) [] X105 \n X106",
+              "goal_text": "hd-beta\n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) [] X105 \n X106",
               "goal_id": 1347
             },
             "cut_branch": {
@@ -40119,8 +38438,7 @@
       "Inference",
       {
         "current_goal_id": 1349,
-        "current_goal_text":
-          "std.append\n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] [] X107",
+        "current_goal_text": "std.append\n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] [] X107",
         "current_goal_predicate": "std.append",
         "failed_attempts": [],
         "successful_attempts": [
@@ -40129,8 +38447,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                  "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                   "rule_loc": [
                     "File",
                     {
@@ -40154,8 +38471,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.append [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] [] \n X108",
+                "goal_text": "std.append [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] [] \n X108",
                 "goal_id": 1351
               }
             ],
@@ -40168,8 +38484,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -40188,8 +38503,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
+                "rule_text": "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -40208,8 +38522,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -40228,8 +38541,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -40248,8 +38560,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -40268,13 +38579,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -40460,13 +38769,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -40485,8 +38792,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -40511,13 +38817,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -40532,8 +38836,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -40565,8 +38868,7 @@
       "Inference",
       {
         "current_goal_id": 1351,
-        "current_goal_text":
-          "std.append [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] [] \n X108",
+        "current_goal_text": "std.append [global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0] [] \n X108",
         "current_goal_predicate": "std.append",
         "failed_attempts": [],
         "successful_attempts": [
@@ -40575,8 +38877,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                  "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                   "rule_loc": [
                     "File",
                     {
@@ -40600,8 +38901,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.append [fun `x` (global (indt «nat»)) c0 \\ c0] [] X109",
+                "goal_text": "std.append [fun `x` (global (indt «nat»)) c0 \\ c0] [] X109",
                 "goal_id": 1352
               }
             ],
@@ -40614,8 +38914,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -40634,8 +38933,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -40654,8 +38952,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
+                "rule_text": "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -40674,8 +38971,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -40694,8 +38990,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -40714,8 +39009,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -40734,13 +39028,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -40926,13 +39218,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -40951,8 +39241,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -40977,13 +39266,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -40998,8 +39285,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -41031,8 +39317,7 @@
       "Inference",
       {
         "current_goal_id": 1352,
-        "current_goal_text":
-          "std.append [fun `x` (global (indt «nat»)) c0 \\ c0] [] X109",
+        "current_goal_text": "std.append [fun `x` (global (indt «nat»)) c0 \\ c0] [] X109",
         "current_goal_predicate": "std.append",
         "failed_attempts": [],
         "successful_attempts": [
@@ -41041,8 +39326,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                  "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                   "rule_loc": [
                     "File",
                     {
@@ -41078,8 +39362,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -41098,8 +39381,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -41118,8 +39400,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -41138,8 +39419,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
+                "rule_text": "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -41158,8 +39438,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -41178,8 +39457,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -41198,8 +39476,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -41218,13 +39495,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -41410,13 +39685,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -41435,8 +39708,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -41461,13 +39733,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -41482,8 +39752,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -41537,8 +39806,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := []" ],
-                [ "Assign", "X110 := []" ]
+                [ "Assign", "A0 := []" ], [ "Assign", "X110 := []" ]
               ]
             },
             "siblings": [],
@@ -41570,8 +39838,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -41590,8 +39857,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -41610,8 +39876,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
+                "rule_text": "(std.append [A0 | A1] A2 [A0 | A3]) :- (std.append A1 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -41630,8 +39895,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
+                "rule_text": "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -41650,8 +39914,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -41670,8 +39933,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -41690,8 +39952,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -41710,13 +39971,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -41902,13 +40161,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -41927,8 +40184,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -41953,13 +40209,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -41974,8 +40228,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -42007,8 +40260,7 @@
       "Inference",
       {
         "current_goal_id": 1350,
-        "current_goal_text":
-          "hd-beta (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
+        "current_goal_text": "hd-beta (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X105 X106",
         "current_goal_predicate": "hd-beta",
         "failed_attempts": [],
         "successful_attempts": [
@@ -42071,8 +40323,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
+                "rule_text": "(hd-beta (app [A0 | A1]) A2 A3 A4) :- (!), (std.append A1 A2 A5), \n (hd-beta A0 A5 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -42091,8 +40342,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -42111,8 +40361,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -42131,8 +40380,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
+                "rule_text": "(hd-beta (fun _ _ A0) [A1 | A2] A3 A4) :- (!), (hd-beta (A0 A1) A2 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -42151,13 +40399,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -42343,13 +40589,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -42368,8 +40612,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -42394,13 +40637,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -42415,8 +40656,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -42448,8 +40688,7 @@
       "Inference",
       {
         "current_goal_id": 1339,
-        "current_goal_text":
-          "unwind (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X82",
+        "current_goal_text": "unwind (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X82",
         "current_goal_predicate": "unwind",
         "failed_attempts": [],
         "successful_attempts": [
@@ -42458,8 +40697,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
+                  "rule_text": "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
                   "rule_loc": [
                     "File",
                     {
@@ -42482,8 +40720,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if (var (global (indc «IsSelfA'.Axioms_»))) \n (coq.mk-app-uvar (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82) \n (coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82)",
+                "goal_text": "if (var (global (indc «IsSelfA'.Axioms_»))) \n (coq.mk-app-uvar (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82) \n (coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82)",
                 "goal_id": 1354
               }
             ],
@@ -42496,8 +40733,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
+                "rule_text": "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
                 "rule_loc": [
                   "File",
                   {
@@ -42516,13 +40752,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -42708,13 +40942,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -42733,8 +40965,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -42759,13 +40990,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -42780,8 +41009,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -42813,8 +41041,7 @@
       "Inference",
       {
         "current_goal_id": 1354,
-        "current_goal_text":
-          "if (var (global (indc «IsSelfA'.Axioms_»))) \n (coq.mk-app-uvar (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82) \n (coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82)",
+        "current_goal_text": "if (var (global (indc «IsSelfA'.Axioms_»))) \n (coq.mk-app-uvar (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82) \n (coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82)",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -42852,8 +41079,7 @@
               },
               { "goal_text": "!", "goal_id": 1356 },
               {
-                "goal_text":
-                  "coq.mk-app-uvar (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X82",
+                "goal_text": "coq.mk-app-uvar (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X82",
                 "goal_id": 1357
               }
             ],
@@ -42885,8 +41111,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
+                "rule_text": "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
                 "rule_loc": [
                   "File",
                   {
@@ -42905,13 +41130,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -43097,13 +41320,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -43122,8 +41343,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -43148,13 +41368,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -43169,8 +41387,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -43238,8 +41455,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
+                "rule_text": "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
                 "rule_loc": [
                   "File",
                   {
@@ -43258,13 +41474,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -43450,13 +41664,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -43475,8 +41687,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -43501,13 +41712,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -43522,8 +41731,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -43555,8 +41763,7 @@
       "Inference",
       {
         "current_goal_id": 1354,
-        "current_goal_text":
-          "if (var (global (indc «IsSelfA'.Axioms_»))) \n (coq.mk-app-uvar (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82) \n (coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82)",
+        "current_goal_text": "if (var (global (indc «IsSelfA'.Axioms_»))) \n (coq.mk-app-uvar (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82) \n (coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n   [global (indt «nat»), global (indc «O»), \n    fun `x` (global (indt «nat»)) c0 \\ c0] X82)",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -43586,8 +41793,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X82",
+                "goal_text": "coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X82",
                 "goal_id": 1358
               }
             ],
@@ -43619,8 +41825,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
+                "rule_text": "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
                 "rule_loc": [
                   "File",
                   {
@@ -43639,13 +41844,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -43831,13 +42034,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -43856,8 +42057,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -43882,13 +42082,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -43903,8 +42101,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -43936,8 +42133,7 @@
       "Inference",
       {
         "current_goal_id": 1358,
-        "current_goal_text":
-          "coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X82",
+        "current_goal_text": "coq.mk-app (global (indc «IsSelfA'.Axioms_»)) \n [global (indt «nat»), global (indc «O»), \n  fun `x` (global (indt «nat»)) c0 \\ c0] X82",
         "current_goal_predicate": "coq.mk-app",
         "failed_attempts": [
           {
@@ -44043,8 +42239,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
+                "rule_text": "(unwind A0 A1 A2) :- (if (var A0) (coq.mk-app-uvar A0 A1 A2) \n                       (coq.mk-app A0 A1 A2)).",
                 "rule_loc": [
                   "File",
                   {
@@ -44063,13 +42258,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
+                "rule_text": "(instance.private.optimize-body (app [global (const A0) | A1]) A2) :- (\n phant-abbrev _ (const A0) _ ;\n  coq.gref->id (const A0) A6 , rex_match phant_ A6), (!), \n (coq.env.const A0 (some A3) _), (hd-beta A3 A1 A4 A5), (unwind A4 A5 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 309,
                     "column": 0,
                     "character": 13433
@@ -44255,13 +42448,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -44280,8 +42471,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -44306,13 +42496,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -44327,8 +42515,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -44366,8 +42553,7 @@
       "Inference",
       {
         "current_goal_id": 1334,
-        "current_goal_text":
-          "std.do!\n [if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [if (_ = _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _), \n  log.coq.env.add-const-noimplicits-failondup X85 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -44376,8 +42562,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -44402,14 +42587,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if (_ = _) \n (, (new_int X83) (std.any->string X83 X84) \n   (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _)",
+                "goal_text": "if (_ = _) \n (, (new_int X83) (std.any->string X83 X84) \n   (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _)",
                 "goal_id": 1359
               },
               { "goal_text": "!", "goal_id": 1360 },
               {
-                "goal_text":
-                  "std.do!\n [log.coq.env.add-const-noimplicits-failondup X85 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [log.coq.env.add-const-noimplicits-failondup X85 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1361
               }
             ],
@@ -44612,13 +42795,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -44637,8 +42818,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -44663,13 +42843,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -44684,8 +42862,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -44717,8 +42894,7 @@
       "Inference",
       {
         "current_goal_id": 1359,
-        "current_goal_text":
-          "if (_ = _) \n (, (new_int X83) (std.any->string X83 X84) \n   (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _)",
+        "current_goal_text": "if (_ = _) \n (, (new_int X83) (std.any->string X83 X84) \n   (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _)",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -44751,8 +42927,7 @@
               { "goal_text": "_ = _", "goal_id": 1362 },
               { "goal_text": "!", "goal_id": 1363 },
               {
-                "goal_text":
-                  ", (new_int X83) (std.any->string X83 X84) (X85 is HB_unnamed_factory_ ^ X84)",
+                "goal_text": ", (new_int X83) (std.any->string X83 X84) (X85 is HB_unnamed_factory_ ^ X84)",
                 "goal_id": 1364
               }
             ],
@@ -44974,13 +43149,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -44999,8 +43172,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -45025,13 +43197,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -45046,8 +43216,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -45312,13 +43481,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -45337,8 +43504,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -45363,13 +43529,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -45384,8 +43548,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -45420,8 +43583,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "if (_ = _) \n (, (new_int X83) (std.any->string X83 X84) \n   (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _)",
+              "goal_text": "if (_ = _) \n (, (new_int X83) (std.any->string X83 X84) \n   (X85 is HB_unnamed_factory_ ^ X84)) (X85 = _)",
               "goal_id": 1359
             },
             "cut_branch": {
@@ -45449,8 +43611,7 @@
       "Inference",
       {
         "current_goal_id": 1364,
-        "current_goal_text":
-          ", (new_int X83) (std.any->string X83 X84) (X85 is HB_unnamed_factory_ ^ X84)",
+        "current_goal_text": ", (new_int X83) (std.any->string X83 X84) (X85 is HB_unnamed_factory_ ^ X84)",
         "current_goal_predicate": ",",
         "failed_attempts": [],
         "successful_attempts": [
@@ -45690,13 +43851,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -45715,8 +43874,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -45741,13 +43899,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -45762,8 +43918,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -46033,13 +44188,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -46058,8 +44211,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -46084,13 +44236,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -46105,8 +44255,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -46381,13 +44530,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -46406,8 +44553,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -46432,13 +44578,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -46453,8 +44597,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -46495,8 +44638,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.any->string A0 A1) :- (term_to_string A0 A1).",
+                  "rule_text": "(std.any->string A0 A1) :- (term_to_string A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -46509,8 +44651,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := 27" ],
-                [ "Assign", "A1 := X84" ]
+                [ "Assign", "A0 := 27" ], [ "Assign", "A1 := X84" ]
               ]
             },
             "siblings": [
@@ -46525,8 +44666,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.any->string A0 A1) :- (term_to_string A0 A1).",
+                "rule_text": "(std.any->string A0 A1) :- (term_to_string A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -46759,13 +44899,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -46784,8 +44922,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -46810,13 +44947,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -46831,8 +44966,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -46888,8 +45022,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.any->string A0 A1) :- (term_to_string A0 A1).",
+                "rule_text": "(std.any->string A0 A1) :- (term_to_string A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -47122,13 +45255,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -47147,8 +45278,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -47173,13 +45303,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -47194,8 +45322,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -47256,8 +45383,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.any->string A0 A1) :- (term_to_string A0 A1).",
+                "rule_text": "(std.any->string A0 A1) :- (term_to_string A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -47490,13 +45616,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -47515,8 +45639,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -47541,13 +45664,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -47562,8 +45683,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -47869,13 +45989,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -47894,8 +46012,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -47920,13 +46037,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -47941,8 +46056,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -48233,13 +46347,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -48258,8 +46370,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -48284,13 +46395,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -48305,8 +46414,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -48600,13 +46708,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -48625,8 +46731,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -48651,13 +46756,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -48672,8 +46775,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -48711,8 +46813,7 @@
       "Inference",
       {
         "current_goal_id": 1361,
-        "current_goal_text":
-          "std.do!\n [log.coq.env.add-const-noimplicits-failondup HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [log.coq.env.add-const-noimplicits-failondup HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -48721,8 +46822,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -48747,14 +46847,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "log.coq.env.add-const-noimplicits-failondup HB_unnamed_factory_27 \n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86",
+                "goal_text": "log.coq.env.add-const-noimplicits-failondup HB_unnamed_factory_27 \n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86",
                 "goal_id": 1373
               },
               { "goal_text": "!", "goal_id": 1374 },
               {
-                "goal_text":
-                  "std.do!\n [X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [X87 = global (const X86), std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1375
               }
             ],
@@ -48976,13 +47074,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -49001,8 +47097,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -49027,13 +47122,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -49048,8 +47141,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -49081,10 +47173,8 @@
       "Inference",
       {
         "current_goal_id": 1373,
-        "current_goal_text":
-          "log.coq.env.add-const-noimplicits-failondup HB_unnamed_factory_27 \n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86",
-        "current_goal_predicate":
-          "log.coq.env.add-const-noimplicits-failondup",
+        "current_goal_text": "log.coq.env.add-const-noimplicits-failondup HB_unnamed_factory_27 \n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86",
+        "current_goal_predicate": "log.coq.env.add-const-noimplicits-failondup",
         "failed_attempts": [],
         "successful_attempts": [
           {
@@ -49092,13 +47182,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                  "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 59,
                       "column": 0,
                       "character": 2355
@@ -49122,8 +47210,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [if\n   (not\n     (ground_term\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n       ground_term\n        (app\n          [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n           global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n   (,\n     (coq.term->string\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n     (coq.term->string\n       (app\n         [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n          global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n     (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n       X111 := X112)) true, \n  coq.env.add-const HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
+                "goal_text": "std.do!\n [if\n   (not\n     (ground_term\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n       ground_term\n        (app\n          [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n           global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n   (,\n     (coq.term->string\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n     (coq.term->string\n       (app\n         [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n          global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n     (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n       X111 := X112)) true, \n  coq.env.add-const HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
                 "goal_id": 1376
               }
             ],
@@ -49136,13 +47223,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -49366,13 +47451,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -49391,8 +47474,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -49417,13 +47499,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -49438,8 +47518,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -49471,8 +47550,7 @@
       "Inference",
       {
         "current_goal_id": 1376,
-        "current_goal_text":
-          "std.do!\n [if\n   (not\n     (ground_term\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n       ground_term\n        (app\n          [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n           global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n   (,\n     (coq.term->string\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n     (coq.term->string\n       (app\n         [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n          global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n     (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n       X111 := X112)) true, \n  coq.env.add-const HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
+        "current_goal_text": "std.do!\n [if\n   (not\n     (ground_term\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n       ground_term\n        (app\n          [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n           global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n   (,\n     (coq.term->string\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n     (coq.term->string\n       (app\n         [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n          global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n     (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n       X111 := X112)) true, \n  coq.env.add-const HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -49481,8 +47559,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -49507,14 +47584,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if\n (not\n   (ground_term\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n     ground_term\n      (app\n        [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n         global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n (,\n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n   (coq.term->string\n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n   (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n     X111 := X112)) true",
+                "goal_text": "if\n (not\n   (ground_term\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n     ground_term\n      (app\n        [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n         global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n (,\n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n   (coq.term->string\n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n   (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n     X111 := X112)) true",
                 "goal_id": 1377
               },
               { "goal_text": "!", "goal_id": 1378 },
               {
-                "goal_text":
-                  "std.do!\n [coq.env.add-const HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
+                "goal_text": "std.do!\n [coq.env.add-const HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
                 "goal_id": 1379
               }
             ],
@@ -49546,13 +47621,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -49776,13 +47849,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -49801,8 +47872,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -49827,13 +47897,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -49848,8 +47916,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -49881,8 +47948,7 @@
       "Inference",
       {
         "current_goal_id": 1377,
-        "current_goal_text":
-          "if\n (not\n   (ground_term\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n     ground_term\n      (app\n        [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n         global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n (,\n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n   (coq.term->string\n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n   (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n     X111 := X112)) true",
+        "current_goal_text": "if\n (not\n   (ground_term\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n     ground_term\n      (app\n        [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n         global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n (,\n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n   (coq.term->string\n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n   (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n     X111 := X112)) true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -49916,14 +47982,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "not\n (ground_term\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n   ground_term\n    (app\n      [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n       global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
+                "goal_text": "not\n (ground_term\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n   ground_term\n    (app\n      [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n       global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
                 "goal_id": 1380
               },
               { "goal_text": "!", "goal_id": 1381 },
               {
-                "goal_text":
-                  ",\n (coq.term->string\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n (coq.term->string\n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n   X111 := X112)",
+                "goal_text": ",\n (coq.term->string\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n (coq.term->string\n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n   X111 := X112)",
                 "goal_id": 1382
               }
             ],
@@ -49974,13 +48038,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -50204,13 +48266,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -50229,8 +48289,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -50255,13 +48314,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -50276,8 +48333,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -50309,8 +48365,7 @@
       "Inference",
       {
         "current_goal_id": 1380,
-        "current_goal_text":
-          "not\n (ground_term\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n   ground_term\n    (app\n      [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n       global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
+        "current_goal_text": "not\n (ground_term\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n   ground_term\n    (app\n      [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n       global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
         "current_goal_predicate": "not",
         "failed_attempts": [],
         "successful_attempts": [
@@ -50340,8 +48395,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])\n ;\n ground_term\n  (app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])",
+                "goal_text": "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])\n ;\n ground_term\n  (app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])",
                 "goal_id": 1383
               },
               { "goal_text": "!", "goal_id": 1384 },
@@ -50413,13 +48467,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -50643,13 +48695,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -50668,8 +48718,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -50694,13 +48743,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -50715,8 +48762,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -50748,8 +48794,7 @@
       "Inference",
       {
         "current_goal_id": 1383,
-        "current_goal_text":
-          "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])\n ;\n ground_term\n  (app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])",
+        "current_goal_text": "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])\n ;\n ground_term\n  (app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -50779,8 +48824,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+                "goal_text": "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
                 "goal_id": 1386
               }
             ],
@@ -50869,13 +48913,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -51099,13 +49141,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -51124,8 +49164,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -51150,13 +49189,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -51171,8 +49208,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -51204,8 +49240,7 @@
       "Inference",
       {
         "current_goal_id": 1386,
-        "current_goal_text":
-          "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+        "current_goal_text": "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
         "current_goal_predicate": "ground_term",
         "failed_attempts": [],
         "successful_attempts": [
@@ -51305,13 +49340,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -51535,13 +49568,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -51560,8 +49591,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -51586,13 +49616,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -51607,8 +49635,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -51643,8 +49670,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])\n ;\n ground_term\n  (app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])",
+              "goal_text": "ground_term (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])\n ;\n ground_term\n  (app\n    [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n     global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])",
               "goal_id": 1383
             },
             "cut_branch": {
@@ -51662,8 +49688,7 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "not\n (ground_term\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n   ground_term\n    (app\n      [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n       global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
+              "goal_text": "not\n (ground_term\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n   ground_term\n    (app\n      [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n       global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
               "goal_id": 1380
             },
             "cut_branch": {
@@ -51758,13 +49783,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -51988,13 +50011,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -52013,8 +50034,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -52039,13 +50059,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -52060,8 +50078,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -52093,8 +50110,7 @@
       "Inference",
       {
         "current_goal_id": 1377,
-        "current_goal_text":
-          "if\n (not\n   (ground_term\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n     ground_term\n      (app\n        [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n         global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n (,\n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n   (coq.term->string\n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n   (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n     X111 := X112)) true",
+        "current_goal_text": "if\n (not\n   (ground_term\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ;\n     ground_term\n      (app\n        [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n         global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))) \n (,\n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X111) \n   (coq.term->string\n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) X112) \n   (coq.error HB: cannot infer some information in HB_unnamed_factory_27 : \n     X111 := X112)) true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -52165,13 +50181,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -52395,13 +50409,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -52420,8 +50432,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -52446,13 +50457,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -52467,8 +50476,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -52590,13 +50598,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -52820,13 +50826,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -52845,8 +50849,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -52871,13 +50874,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -52892,8 +50893,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -52931,8 +50931,7 @@
       "Inference",
       {
         "current_goal_id": 1379,
-        "current_goal_text":
-          "std.do!\n [coq.env.add-const HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
+        "current_goal_text": "std.do!\n [coq.env.add-const HB_unnamed_factory_27 \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86, \n  log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -52941,8 +50940,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -52967,14 +50965,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.env.add-const HB_unnamed_factory_27 \n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86",
+                "goal_text": "coq.env.add-const HB_unnamed_factory_27 \n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86",
                 "goal_id": 1388
               },
               { "goal_text": "!", "goal_id": 1389 },
               {
-                "goal_text":
-                  "std.do!\n [log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
+                "goal_text": "std.do!\n [log.coq.env.add-location (const X86), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const X86) [[]]]",
                 "goal_id": 1390
               }
             ],
@@ -53025,13 +51021,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -53255,13 +51249,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -53280,8 +51272,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -53306,13 +51297,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -53327,8 +51316,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -53360,8 +51348,7 @@
       "Inference",
       {
         "current_goal_id": 1388,
-        "current_goal_text":
-          "coq.env.add-const HB_unnamed_factory_27 \n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86",
+        "current_goal_text": "coq.env.add-const HB_unnamed_factory_27 \n (app\n   [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n    global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]) \n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) ff X86",
         "current_goal_predicate": "coq.env.add-const",
         "failed_attempts": [],
         "successful_attempts": [
@@ -53428,13 +51415,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -53658,13 +51643,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -53683,8 +51666,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -53709,13 +51691,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -53730,8 +51710,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -53830,13 +51809,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -54060,13 +52037,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -54085,8 +52060,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -54111,13 +52085,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -54132,8 +52104,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -54171,8 +52142,7 @@
       "Inference",
       {
         "current_goal_id": 1390,
-        "current_goal_text":
-          "std.do!\n [log.coq.env.add-location (const «HB_unnamed_factory_27»), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
+        "current_goal_text": "std.do!\n [log.coq.env.add-location (const «HB_unnamed_factory_27»), \n  if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -54181,8 +52151,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -54207,14 +52176,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "log.coq.env.add-location (const «HB_unnamed_factory_27»)",
+                "goal_text": "log.coq.env.add-location (const «HB_unnamed_factory_27»)",
                 "goal_id": 1392
               },
               { "goal_text": "!", "goal_id": 1393 },
               {
-                "goal_text":
-                  "std.do!\n [if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
+                "goal_text": "std.do!\n [if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
                 "goal_id": 1394
               }
             ],
@@ -54284,13 +52251,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -54514,13 +52479,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -54539,8 +52502,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -54565,13 +52527,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -54586,8 +52546,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -54619,8 +52578,7 @@
       "Inference",
       {
         "current_goal_id": 1392,
-        "current_goal_text":
-          "log.coq.env.add-location (const «HB_unnamed_factory_27»)",
+        "current_goal_text": "log.coq.env.add-location (const «HB_unnamed_factory_27»)",
         "current_goal_predicate": "log.coq.env.add-location",
         "failed_attempts": [],
         "successful_attempts": [
@@ -54629,13 +52587,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
+                  "rule_text": "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 21,
                       "column": 0,
                       "character": 831
@@ -54649,8 +52605,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if (get-option elpi.loc X114) \n (acc-clause library (decl-location (const «HB_unnamed_factory_27») X114)) \n true",
+                "goal_text": "if (get-option elpi.loc X114) \n (acc-clause library (decl-location (const «HB_unnamed_factory_27») X114)) \n true",
                 "goal_id": 1395
               }
             ],
@@ -54663,13 +52618,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
+                "rule_text": "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 21,
                     "column": 0,
                     "character": 831
@@ -54741,13 +52694,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -54971,13 +52922,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -54996,8 +52945,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -55022,13 +52970,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -55043,8 +52989,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -55076,8 +53021,7 @@
       "Inference",
       {
         "current_goal_id": 1395,
-        "current_goal_text":
-          "if (get-option elpi.loc X114) \n (acc-clause library (decl-location (const «HB_unnamed_factory_27») X114)) \n true",
+        "current_goal_text": "if (get-option elpi.loc X114) \n (acc-clause library (decl-location (const «HB_unnamed_factory_27») X114)) \n true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -55110,8 +53054,7 @@
               { "goal_text": "get-option elpi.loc X114", "goal_id": 1396 },
               { "goal_text": "!", "goal_id": 1397 },
               {
-                "goal_text":
-                  "acc-clause library (decl-location (const «HB_unnamed_factory_27») X114)",
+                "goal_text": "acc-clause library (decl-location (const «HB_unnamed_factory_27») X114)",
                 "goal_id": 1398
               }
             ],
@@ -55143,13 +53086,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
+                "rule_text": "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 21,
                     "column": 0,
                     "character": 831
@@ -55221,13 +53162,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -55451,13 +53390,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -55476,8 +53413,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -55502,13 +53438,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -55523,8 +53457,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -55565,8 +53498,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:) :- .",
+                  "rule_text": "(get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:) :- .",
                   "rule_loc": [ "Context", 74 ]
                 }
               ],
@@ -55587,8 +53519,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:) :- .",
+                "rule_text": "(get-option elpi.loc File \"(stdin)\", line 1, column 2, character 3:) :- .",
                 "rule_loc": [ "Context", 74 ]
               }
             ],
@@ -55618,13 +53549,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
+                "rule_text": "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 21,
                     "column": 0,
                     "character": 831
@@ -55696,13 +53625,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -55926,13 +53853,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -55951,8 +53876,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -55977,13 +53901,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -55998,8 +53920,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -56034,8 +53955,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "if (get-option elpi.loc X114) \n (acc-clause library (decl-location (const «HB_unnamed_factory_27») X114)) \n true",
+              "goal_text": "if (get-option elpi.loc X114) \n (acc-clause library (decl-location (const «HB_unnamed_factory_27») X114)) \n true",
               "goal_id": 1395
             },
             "cut_branch": {
@@ -56063,8 +53983,7 @@
       "Inference",
       {
         "current_goal_id": 1398,
-        "current_goal_text":
-          "acc-clause library \n (decl-location (const «HB_unnamed_factory_27») \n   File \"(stdin)\", line 1, column 2, character 3:)",
+        "current_goal_text": "acc-clause library \n (decl-location (const «HB_unnamed_factory_27») \n   File \"(stdin)\", line 1, column 2, character 3:)",
         "current_goal_predicate": "acc-clause",
         "failed_attempts": [],
         "successful_attempts": [
@@ -56073,13 +53992,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(acc-clause A0 A1) :- (coq.elpi.accumulate A0 hb.db (clause _ _ A1)).",
+                  "rule_text": "(acc-clause A0 A1) :- (coq.elpi.accumulate A0 hb.db (clause _ _ A1)).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 75,
                       "column": 0,
                       "character": 2237
@@ -56097,8 +54014,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.elpi.accumulate library hb.db \n (clause _ _ \n   (decl-location (const «HB_unnamed_factory_27») \n     File \"(stdin)\", line 1, column 2, character 3:))",
+                "goal_text": "coq.elpi.accumulate library hb.db \n (clause _ _ \n   (decl-location (const «HB_unnamed_factory_27») \n     File \"(stdin)\", line 1, column 2, character 3:))",
                 "goal_id": 1399
               }
             ],
@@ -56111,13 +54027,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(acc-clause A0 A1) :- (coq.elpi.accumulate A0 hb.db (clause _ _ A1)).",
+                "rule_text": "(acc-clause A0 A1) :- (coq.elpi.accumulate A0 hb.db (clause _ _ A1)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2237
@@ -56151,13 +54065,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
+                "rule_text": "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 21,
                     "column": 0,
                     "character": 831
@@ -56229,13 +54141,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -56459,13 +54369,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -56484,8 +54392,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -56510,13 +54417,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -56531,8 +54436,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -56564,8 +54468,7 @@
       "Inference",
       {
         "current_goal_id": 1399,
-        "current_goal_text":
-          "coq.elpi.accumulate library hb.db \n (clause _ _ \n   (decl-location (const «HB_unnamed_factory_27») \n     File \"(stdin)\", line 1, column 2, character 3:))",
+        "current_goal_text": "coq.elpi.accumulate library hb.db \n (clause _ _ \n   (decl-location (const «HB_unnamed_factory_27») \n     File \"(stdin)\", line 1, column 2, character 3:))",
         "current_goal_predicate": "coq.elpi.accumulate",
         "failed_attempts": [],
         "successful_attempts": [
@@ -56589,13 +54492,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(acc-clause A0 A1) :- (coq.elpi.accumulate A0 hb.db (clause _ _ A1)).",
+                "rule_text": "(acc-clause A0 A1) :- (coq.elpi.accumulate A0 hb.db (clause _ _ A1)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2237
@@ -56629,13 +54530,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
+                "rule_text": "(log.coq.env.add-location A0) :- (if (get-option elpi.loc A1) \n                                   (acc-clause library (decl-location A0 A1)) \n                                   true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 21,
                     "column": 0,
                     "character": 831
@@ -56707,13 +54606,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -56937,13 +54834,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -56962,8 +54857,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -56988,13 +54882,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -57009,8 +54901,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -57048,8 +54939,7 @@
       "Inference",
       {
         "current_goal_id": 1394,
-        "current_goal_text":
-          "std.do!\n [if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
+        "current_goal_text": "std.do!\n [if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (X113 = none) \n   (X113 =\n     some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])), \n  log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -57058,8 +54948,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -57084,14 +54973,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (X113 = none) \n (X113 =\n   some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]))",
+                "goal_text": "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (X113 = none) \n (X113 =\n   some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]))",
                 "goal_id": 1400
               },
               { "goal_text": "!", "goal_id": 1401 },
               {
-                "goal_text":
-                  "std.do!\n [log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
+                "goal_text": "std.do!\n [log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 X113 \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
                 "goal_id": 1402
               }
             ],
@@ -57180,13 +55067,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -57410,13 +55295,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -57435,8 +55318,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -57461,13 +55343,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -57482,8 +55362,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -57515,8 +55394,7 @@
       "Inference",
       {
         "current_goal_id": 1400,
-        "current_goal_text":
-          "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (X113 = none) \n (X113 =\n   some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]))",
+        "current_goal_text": "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (X113 = none) \n (X113 =\n   some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]))",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -57547,8 +55425,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+                "goal_text": "var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
                 "goal_id": 1403
               },
               { "goal_text": "!", "goal_id": 1404 },
@@ -57658,13 +55535,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -57888,13 +55763,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -57913,8 +55786,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -57939,13 +55811,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -57960,8 +55830,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -57993,8 +55862,7 @@
       "Inference",
       {
         "current_goal_id": 1403,
-        "current_goal_text":
-          "var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+        "current_goal_text": "var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
         "current_goal_predicate": "var",
         "failed_attempts": [
           { "rule": [ "BuiltinRule", [ "FFI", "var" ] ], "events": [] }
@@ -58106,13 +55974,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -58336,13 +56202,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -58361,8 +56225,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -58387,13 +56250,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -58408,8 +56269,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -58441,8 +56301,7 @@
       "Inference",
       {
         "current_goal_id": 1400,
-        "current_goal_text":
-          "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (X113 = none) \n (X113 =\n   some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]))",
+        "current_goal_text": "if (var (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n (X113 = none) \n (X113 =\n   some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]))",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -58472,8 +56331,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X113 = some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+                "goal_text": "X113 = some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
                 "goal_id": 1406
               }
             ],
@@ -58581,13 +56439,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -58811,13 +56667,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -58836,8 +56690,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -58862,13 +56715,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -58883,8 +56734,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -58916,8 +56766,7 @@
       "Inference",
       {
         "current_goal_id": 1406,
-        "current_goal_text":
-          "X113 = some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
+        "current_goal_text": "X113 = some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -59041,13 +56890,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -59271,13 +57118,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -59296,8 +57141,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -59322,13 +57166,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -59343,8 +57185,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -59382,8 +57223,7 @@
       "Inference",
       {
         "current_goal_id": 1402,
-        "current_goal_text":
-          "std.do!\n [log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 \n     (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
+        "current_goal_text": "std.do!\n [log.private.log-vernac\n   (log.private.coq.vernac.definition HB_unnamed_factory_27 \n     (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n     (app\n       [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n        global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])), \n  get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -59392,8 +57232,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -59418,14 +57257,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "log.private.log-vernac\n (log.private.coq.vernac.definition HB_unnamed_factory_27 \n   (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
+                "goal_text": "log.private.log-vernac\n (log.private.coq.vernac.definition HB_unnamed_factory_27 \n   (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
                 "goal_id": 1407
               },
               { "goal_text": "!", "goal_id": 1408 },
               {
-                "goal_text":
-                  "std.do!\n [get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
+                "goal_text": "std.do!\n [get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
                 "goal_id": 1409
               }
             ],
@@ -59533,13 +57370,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -59763,13 +57598,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -59788,8 +57621,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -59814,13 +57646,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -59835,8 +57665,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -59868,8 +57697,7 @@
       "Inference",
       {
         "current_goal_id": 1407,
-        "current_goal_text":
-          "log.private.log-vernac\n (log.private.coq.vernac.definition HB_unnamed_factory_27 \n   (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
+        "current_goal_text": "log.private.log-vernac\n (log.private.coq.vernac.definition HB_unnamed_factory_27 \n   (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
         "current_goal_predicate": "log.private.log-vernac",
         "failed_attempts": [],
         "successful_attempts": [
@@ -59878,13 +57706,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
+                  "rule_text": "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 291,
                       "column": 0,
                       "character": 11441
@@ -59906,13 +57732,11 @@
               },
               { "goal_text": "!", "goal_id": 1411 },
               {
-                "goal_text":
-                  "if (X116 = tt) (X117 = []) (X117 = [get-option coq:pp all])",
+                "goal_text": "if (X116 = tt) (X117 = []) (X117 = [get-option coq:pp all])",
                 "goal_id": 1412
               },
               {
-                "goal_text":
-                  "X117 =>\n log.private.coq.vernac->pp\n  [log.private.coq.vernac.definition HB_unnamed_factory_27 \n    (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n    (app\n      [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n       global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])] X118",
+                "goal_text": "X117 =>\n log.private.coq.vernac->pp\n  [log.private.coq.vernac.definition HB_unnamed_factory_27 \n    (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n    (app\n      [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n       global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0])] X118",
                 "goal_id": 1413
               },
               {
@@ -59929,13 +57753,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
+                "rule_text": "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 291,
                     "column": 0,
                     "character": 11441
@@ -60045,13 +57867,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -60275,13 +58095,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -60300,8 +58118,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -60326,13 +58143,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -60347,8 +58162,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -60390,13 +58204,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
+                "rule_text": "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 291,
                     "column": 0,
                     "character": 11441
@@ -60506,13 +58318,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -60736,13 +58546,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -60761,8 +58569,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -60787,13 +58594,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -60808,8 +58613,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -60841,8 +58645,7 @@
       "Inference",
       {
         "current_goal_id": 1407,
-        "current_goal_text":
-          "log.private.log-vernac\n (log.private.coq.vernac.definition HB_unnamed_factory_27 \n   (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
+        "current_goal_text": "log.private.log-vernac\n (log.private.coq.vernac.definition HB_unnamed_factory_27 \n   (some (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)])) \n   (app\n     [global (indc «IsSelfA'.Axioms_»), global (indt «nat»), \n      global (indc «O»), fun `x` (global (indt «nat»)) c0 \\ c0]))",
         "current_goal_predicate": "log.private.log-vernac",
         "failed_attempts": [],
         "successful_attempts": [
@@ -60855,8 +58658,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 294,
                       "column": 0,
                       "character": 11623
@@ -60880,8 +58682,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 294,
                     "column": 0,
                     "character": 11623
@@ -60991,13 +58792,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -61221,13 +59020,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -61246,8 +59043,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -61272,13 +59068,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -61293,8 +59087,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -61332,8 +59125,7 @@
       "Inference",
       {
         "current_goal_id": 1409,
-        "current_goal_text":
-          "std.do!\n [get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
+        "current_goal_text": "std.do!\n [get-option coq:locality local =>\n   log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -61342,8 +59134,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -61365,8 +59156,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "get-option coq:locality local =>\n log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
+                "goal_text": "get-option coq:locality local =>\n log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
                 "goal_id": 1415
               },
               { "goal_text": "!", "goal_id": 1416 },
@@ -61495,13 +59285,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -61725,13 +59513,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -61750,8 +59536,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -61776,13 +59561,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -61797,8 +59580,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -61830,8 +59612,7 @@
       "Inference",
       {
         "current_goal_id": 1415,
-        "current_goal_text":
-          "get-option coq:locality local =>\n log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
+        "current_goal_text": "get-option coq:locality local =>\n log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -61842,8 +59623,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
+                "goal_text": "log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
                 "goal_id": 1418
               }
             ],
@@ -61975,13 +59755,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -62205,13 +59983,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -62230,8 +60006,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -62256,13 +60031,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -62277,8 +60050,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -62310,8 +60082,7 @@
       "Inference",
       {
         "current_goal_id": 1418,
-        "current_goal_text":
-          "log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
+        "current_goal_text": "log.coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
         "current_goal_predicate": "log.coq.arguments.set-implicit",
         "failed_attempts": [],
         "successful_attempts": [
@@ -62320,13 +60091,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                  "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 14,
                       "column": 0,
                       "character": 592
@@ -62341,8 +60110,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]], \n  if (get-option coq:locality local) (X119 = tt) (X119 = ff), \n  (coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
+                "goal_text": "std.do!\n [coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]], \n  if (get-option coq:locality local) (X119 = tt) (X119 = ff), \n  (coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
                 "goal_id": 1419
               }
             ],
@@ -62355,13 +60123,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -62495,13 +60261,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -62725,13 +60489,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -62750,8 +60512,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -62776,13 +60537,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -62797,8 +60556,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -62830,8 +60588,7 @@
       "Inference",
       {
         "current_goal_id": 1419,
-        "current_goal_text":
-          "std.do!\n [coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]], \n  if (get-option coq:locality local) (X119 = tt) (X119 = ff), \n  (coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
+        "current_goal_text": "std.do!\n [coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]], \n  if (get-option coq:locality local) (X119 = tt) (X119 = ff), \n  (coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -62840,8 +60597,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -62866,14 +60622,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
+                "goal_text": "coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
                 "goal_id": 1420
               },
               { "goal_text": "!", "goal_id": 1421 },
               {
-                "goal_text":
-                  "std.do!\n [if (get-option coq:locality local) (X119 = tt) (X119 = ff), \n  (coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
+                "goal_text": "std.do!\n [if (get-option coq:locality local) (X119 = tt) (X119 = ff), \n  (coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
                 "goal_id": 1422
               }
             ],
@@ -62905,13 +60659,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -63045,13 +60797,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -63275,13 +61025,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -63300,8 +61048,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -63326,13 +61073,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -63347,8 +61092,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -63380,16 +61124,14 @@
       "Inference",
       {
         "current_goal_id": 1420,
-        "current_goal_text":
-          "coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
+        "current_goal_text": "coq.arguments.set-implicit (const «HB_unnamed_factory_27») [[]]",
         "current_goal_predicate": "coq.arguments.set-implicit",
         "failed_attempts": [],
         "successful_attempts": [
           {
             "attempt": {
               "rule": [
-                "BuiltinRule",
-                [ "FFI", "coq.arguments.set-implicit" ]
+                "BuiltinRule", [ "FFI", "coq.arguments.set-implicit" ]
               ],
               "events": []
             },
@@ -63401,8 +61143,7 @@
         "stack": [
           {
             "rule": [
-              "BuiltinRule",
-              [ "FFI", "coq.arguments.set-implicit" ]
+              "BuiltinRule", [ "FFI", "coq.arguments.set-implicit" ]
             ],
             "step_id": 261,
             "runtime_id": 8
@@ -63430,13 +61171,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -63570,13 +61309,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -63800,13 +61537,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -63825,8 +61560,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -63851,13 +61585,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -63872,8 +61604,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -63911,8 +61642,7 @@
       "Inference",
       {
         "current_goal_id": 1422,
-        "current_goal_text":
-          "std.do!\n [if (get-option coq:locality local) (X119 = tt) (X119 = ff), \n  (coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
+        "current_goal_text": "std.do!\n [if (get-option coq:locality local) (X119 = tt) (X119 = ff), \n  (coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -63921,8 +61651,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -63947,14 +61676,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if (get-option coq:locality local) (X119 = tt) (X119 = ff)",
+                "goal_text": "if (get-option coq:locality local) (X119 = tt) (X119 = ff)",
                 "goal_id": 1423
               },
               { "goal_text": "!", "goal_id": 1424 },
               {
-                "goal_text":
-                  "std.do!\n [(coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
+                "goal_text": "std.do!\n [(coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit X119 X120 [[]]))]",
                 "goal_id": 1425
               }
             ],
@@ -64005,13 +61732,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -64145,13 +61870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -64375,13 +62098,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -64400,8 +62121,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -64426,13 +62146,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -64447,8 +62165,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -64480,8 +62197,7 @@
       "Inference",
       {
         "current_goal_id": 1423,
-        "current_goal_text":
-          "if (get-option coq:locality local) (X119 = tt) (X119 = ff)",
+        "current_goal_text": "if (get-option coq:locality local) (X119 = tt) (X119 = ff)",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -64581,13 +62297,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -64721,13 +62435,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -64951,13 +62663,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -64976,8 +62686,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -65002,13 +62711,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -65023,8 +62730,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -65149,13 +62855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -65289,13 +62993,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -65519,13 +63221,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -65544,8 +63244,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -65570,13 +63269,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -65591,8 +63288,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -65627,8 +63323,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "if (get-option coq:locality local) (X119 = tt) (X119 = ff)",
+              "goal_text": "if (get-option coq:locality local) (X119 = tt) (X119 = ff)",
               "goal_id": 1423
             },
             "cut_branch": {
@@ -65737,13 +63432,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -65877,13 +63570,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -66107,13 +63798,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -66132,8 +63821,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -66158,13 +63846,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -66179,8 +63865,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -66218,8 +63903,7 @@
       "Inference",
       {
         "current_goal_id": 1425,
-        "current_goal_text":
-          "std.do!\n [(coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit tt X120 [[]]))]",
+        "current_goal_text": "std.do!\n [(coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n    log.private.log-vernac (log.private.coq.vernac.implicit tt X120 [[]]))]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -66228,8 +63912,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -66251,8 +63934,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n log.private.log-vernac (log.private.coq.vernac.implicit tt X120 [[]])",
+                "goal_text": "coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n log.private.log-vernac (log.private.coq.vernac.implicit tt X120 [[]])",
                 "goal_id": 1429
               },
               { "goal_text": "!", "goal_id": 1430 },
@@ -66324,13 +64006,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -66464,13 +64144,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -66694,13 +64372,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -66719,8 +64395,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -66745,13 +64420,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -66766,8 +64439,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -66799,8 +64471,7 @@
       "Inference",
       {
         "current_goal_id": 1429,
-        "current_goal_text":
-          "coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n log.private.log-vernac (log.private.coq.vernac.implicit tt X120 [[]])",
+        "current_goal_text": "coq.gref->id (const «HB_unnamed_factory_27») X120 ,\n log.private.log-vernac (log.private.coq.vernac.implicit tt X120 [[]])",
         "current_goal_predicate": ",",
         "failed_attempts": [],
         "successful_attempts": [
@@ -66811,13 +64482,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.gref->id (const «HB_unnamed_factory_27») X120",
+                "goal_text": "coq.gref->id (const «HB_unnamed_factory_27») X120",
                 "goal_id": 1432
               },
               {
-                "goal_text":
-                  "log.private.log-vernac (log.private.coq.vernac.implicit tt X120 [[]])",
+                "goal_text": "log.private.log-vernac (log.private.coq.vernac.implicit tt X120 [[]])",
                 "goal_id": 1433
               }
             ],
@@ -66892,13 +64561,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -67032,13 +64699,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -67262,13 +64927,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -67287,8 +64950,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -67313,13 +64975,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -67334,8 +64994,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -67367,8 +65026,7 @@
       "Inference",
       {
         "current_goal_id": 1432,
-        "current_goal_text":
-          "coq.gref->id (const «HB_unnamed_factory_27») X120",
+        "current_goal_text": "coq.gref->id (const «HB_unnamed_factory_27») X120",
         "current_goal_predicate": "coq.gref->id",
         "failed_attempts": [],
         "successful_attempts": [
@@ -67459,13 +65117,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -67599,13 +65255,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -67829,13 +65483,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -67854,8 +65506,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -67880,13 +65531,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -67901,8 +65550,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -68025,13 +65673,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -68165,13 +65811,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -68395,13 +66039,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -68420,8 +66062,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -68446,13 +66087,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -68467,8 +66106,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -68500,8 +66138,7 @@
       "Inference",
       {
         "current_goal_id": 1433,
-        "current_goal_text":
-          "log.private.log-vernac\n (log.private.coq.vernac.implicit tt HB_unnamed_factory_27 [[]])",
+        "current_goal_text": "log.private.log-vernac\n (log.private.coq.vernac.implicit tt HB_unnamed_factory_27 [[]])",
         "current_goal_predicate": "log.private.log-vernac",
         "failed_attempts": [],
         "successful_attempts": [
@@ -68510,13 +66147,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
+                  "rule_text": "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 291,
                       "column": 0,
                       "character": 11441
@@ -68538,13 +66173,11 @@
               },
               { "goal_text": "!", "goal_id": 1436 },
               {
-                "goal_text":
-                  "if (X122 = tt) (X123 = []) (X123 = [get-option coq:pp all])",
+                "goal_text": "if (X122 = tt) (X123 = []) (X123 = [get-option coq:pp all])",
                 "goal_id": 1437
               },
               {
-                "goal_text":
-                  "X123 =>\n log.private.coq.vernac->pp\n  [log.private.coq.vernac.implicit tt HB_unnamed_factory_27 [[]]] X124",
+                "goal_text": "X123 =>\n log.private.coq.vernac->pp\n  [log.private.coq.vernac.implicit tt HB_unnamed_factory_27 [[]]] X124",
                 "goal_id": 1438
               },
               {
@@ -68561,13 +66194,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
+                "rule_text": "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 291,
                     "column": 0,
                     "character": 11441
@@ -68644,13 +66275,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -68784,13 +66413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -69014,13 +66641,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -69039,8 +66664,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -69065,13 +66689,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -69086,8 +66708,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -69129,13 +66750,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
+                "rule_text": "(log.private.log-vernac A0) :- (log.private.logger A1 A2), (!), \n (if (A2 = tt) (A3 = []) (A3 = [get-option coq:pp all])), \n (A3 => log.private.coq.vernac->pp [A0] A4), \n (log.private.logger-extend A1 A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 291,
                     "column": 0,
                     "character": 11441
@@ -69212,13 +66831,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -69352,13 +66969,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -69582,13 +67197,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -69607,8 +67220,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -69633,13 +67245,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -69654,8 +67264,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -69687,8 +67296,7 @@
       "Inference",
       {
         "current_goal_id": 1433,
-        "current_goal_text":
-          "log.private.log-vernac\n (log.private.coq.vernac.implicit tt HB_unnamed_factory_27 [[]])",
+        "current_goal_text": "log.private.log-vernac\n (log.private.coq.vernac.implicit tt HB_unnamed_factory_27 [[]])",
         "current_goal_predicate": "log.private.log-vernac",
         "failed_attempts": [],
         "successful_attempts": [
@@ -69701,8 +67309,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                       "line": 294,
                       "column": 0,
                       "character": 11623
@@ -69726,8 +67333,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 294,
                     "column": 0,
                     "character": 11623
@@ -69804,13 +67410,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -69944,13 +67548,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -70174,13 +67776,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -70199,8 +67799,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -70225,13 +67824,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -70246,8 +67843,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -70394,13 +67990,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
+                "rule_text": "(log.coq.arguments.set-implicit A0 A1) :- (std.do!\n                                            [coq.arguments.set-implicit A0 A1, \n                                             if\n                                              (get-option coq:locality local) \n                                              (A2 = tt) (A2 = ff), \n                                             (coq.gref->id A0 A3 ,\n                                               log.private.log-vernac\n                                                (log.private.coq.vernac.implicit\n                                                  A2 A3 A1))]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 592
@@ -70534,13 +68128,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -70764,13 +68356,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -70789,8 +68379,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -70815,13 +68404,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -70836,8 +68423,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -71041,13 +68627,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
+                "rule_text": "(log.coq.env.add-const-noimplicits-failondup A0 A1 A2 A3 A4) :- (std.do!\n                                                                  [if\n                                                                    (\n                                                                    not\n                                                                    (ground_term\n                                                                    A2 ;\n                                                                    ground_term\n                                                                    A1)) \n                                                                    (\n                                                                    ,\n                                                                    (coq.term->string\n                                                                    A2 A6) \n                                                                    (coq.term->string\n                                                                    A1 A7) \n                                                                    (coq.error\n                                                                    HB: cannot infer some information in \n                                                                    A0 : A6 \n                                                                    := A7)) \n                                                                    true, \n                                                                   coq.env.add-const\n                                                                    A0 A1 A2 \n                                                                    A3 A4, \n                                                                   log.coq.env.add-location\n                                                                    (\n                                                                    const A4), \n                                                                   if\n                                                                    (\n                                                                    var A2) \n                                                                    (\n                                                                    A5 = none) \n                                                                    (\n                                                                    A5 =\n                                                                    some A2), \n                                                                   log.private.log-vernac\n                                                                    (\n                                                                    log.private.coq.vernac.definition\n                                                                    A0 A5 A1), \n                                                                   get-option\n                                                                    coq:locality \n                                                                    local =>\n                                                                    log.coq.arguments.set-implicit\n                                                                    (const A4) \n                                                                    [[]]]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 59,
                     "column": 0,
                     "character": 2355
@@ -71271,13 +68855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -71296,8 +68878,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -71322,13 +68903,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -71343,8 +68922,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -71382,8 +68960,7 @@
       "Inference",
       {
         "current_goal_id": 1375,
-        "current_goal_text":
-          "std.do!\n [X87 = global (const «HB_unnamed_factory_27»), \n  std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [X87 = global (const «HB_unnamed_factory_27»), \n  std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -71392,8 +68969,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -71423,8 +68999,7 @@
               },
               { "goal_text": "!", "goal_id": 1441 },
               {
-                "goal_text":
-                  "std.do!\n [std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 X87 X89 \n   X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1442
               }
             ],
@@ -71665,13 +69240,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -71690,8 +69263,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -71716,13 +69288,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -71737,8 +69307,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -72026,13 +69595,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -72051,8 +69618,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -72077,13 +69643,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -72098,8 +69662,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -72137,8 +69700,7 @@
       "Inference",
       {
         "current_goal_id": 1442,
-        "current_goal_text":
-          "std.do!\n [std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 \n   (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [std.drop 0 [global (indt «nat»)] [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 \n   (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -72147,8 +69709,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -72178,8 +69739,7 @@
               },
               { "goal_text": "!", "goal_id": 1444 },
               {
-                "goal_text":
-                  "std.do!\n [instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 \n   (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [instance.private.check-non-forgetful-inheritance X88 \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») X88 \n   (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1445
               }
             ],
@@ -72439,13 +69999,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -72464,8 +70022,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -72490,13 +70047,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -72511,8 +70066,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -72846,13 +70400,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -72871,8 +70423,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -72897,13 +70448,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -72918,8 +70467,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -72958,8 +70506,7 @@
               "goal_id": 1443
             },
             "cut_branch": {
-              "rule_text":
-                "(std.drop A0 [_ | A1] A2) :- (!), (A3 is A0 - 1), (std.drop A3 A1 A2).",
+              "rule_text": "(std.drop A0 [_ | A1] A2) :- (!), (A3 is A0 - 1), (std.drop A3 A1 A2).",
               "rule_loc": [
                 "File",
                 {
@@ -72977,8 +70524,7 @@
               "goal_id": 1443
             },
             "cut_branch": {
-              "rule_text":
-                "(std.drop _ _ _) :- (std.fatal-error drop run out of list items).",
+              "rule_text": "(std.drop _ _ _) :- (std.fatal-error drop run out of list items).",
               "rule_loc": [
                 "File",
                 {
@@ -73008,8 +70554,7 @@
       "Inference",
       {
         "current_goal_id": 1445,
-        "current_goal_text":
-          "std.do!\n [instance.private.check-non-forgetful-inheritance (global (indt «nat»)) \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») \n   (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [instance.private.check-non-forgetful-inheritance (global (indt «nat»)) \n   (indt «IsSelfA'.axioms_»), \n  instance.private.declare-instance (indt «IsSelfA'.axioms_») \n   (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -73018,8 +70563,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -73044,14 +70588,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "instance.private.check-non-forgetful-inheritance (global (indt «nat»)) \n (indt «IsSelfA'.axioms_»)",
+                "goal_text": "instance.private.check-non-forgetful-inheritance (global (indt «nat»)) \n (indt «IsSelfA'.axioms_»)",
                 "goal_id": 1447
               },
               { "goal_text": "!", "goal_id": 1448 },
               {
-                "goal_text":
-                  "std.do!\n [instance.private.declare-instance (indt «IsSelfA'.axioms_») \n   (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [instance.private.declare-instance (indt «IsSelfA'.axioms_») \n   (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1449
               }
             ],
@@ -73330,13 +70872,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -73355,8 +70895,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -73381,13 +70920,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -73402,8 +70939,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -73435,10 +70971,8 @@
       "Inference",
       {
         "current_goal_id": 1447,
-        "current_goal_text":
-          "instance.private.check-non-forgetful-inheritance (global (indt «nat»)) \n (indt «IsSelfA'.axioms_»)",
-        "current_goal_predicate":
-          "instance.private.check-non-forgetful-inheritance",
+        "current_goal_text": "instance.private.check-non-forgetful-inheritance (global (indt «nat»)) \n (indt «IsSelfA'.axioms_»)",
+        "current_goal_predicate": "instance.private.check-non-forgetful-inheritance",
         "failed_attempts": [],
         "successful_attempts": [
           {
@@ -73446,13 +70980,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.private.check-non-forgetful-inheritance _ _) :- (get-option\n                                                            non_forgetful_inheritance \n                                                            tt), (!).",
+                  "rule_text": "(instance.private.check-non-forgetful-inheritance _ _) :- (get-option\n                                                            non_forgetful_inheritance \n                                                            tt), (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 341,
                       "column": 0,
                       "character": 14872
@@ -73478,13 +71010,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance _ _) :- (get-option\n                                                            non_forgetful_inheritance \n                                                            tt), (!).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance _ _) :- (get-option\n                                                            non_forgetful_inheritance \n                                                            tt), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 341,
                     "column": 0,
                     "character": 14872
@@ -73765,13 +71295,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -73790,8 +71318,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -73816,13 +71343,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -73837,8 +71362,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -73880,13 +71404,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance _ _) :- (get-option\n                                                            non_forgetful_inheritance \n                                                            tt), (!).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance _ _) :- (get-option\n                                                            non_forgetful_inheritance \n                                                            tt), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 341,
                     "column": 0,
                     "character": 14872
@@ -74167,13 +71689,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -74192,8 +71712,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -74218,13 +71737,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -74239,8 +71756,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -74272,10 +71788,8 @@
       "Inference",
       {
         "current_goal_id": 1447,
-        "current_goal_text":
-          "instance.private.check-non-forgetful-inheritance (global (indt «nat»)) \n (indt «IsSelfA'.axioms_»)",
-        "current_goal_predicate":
-          "instance.private.check-non-forgetful-inheritance",
+        "current_goal_text": "instance.private.check-non-forgetful-inheritance (global (indt «nat»)) \n (indt «IsSelfA'.axioms_»)",
+        "current_goal_predicate": "instance.private.check-non-forgetful-inheritance",
         "failed_attempts": [],
         "successful_attempts": [
           {
@@ -74283,13 +71797,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
+                  "rule_text": "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 343,
                       "column": 0,
                       "character": 14959
@@ -74304,8 +71816,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [if\n   (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n     structure-key X125 _ X126) \n   (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n     (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n     (coq.warning HB HB.non-forgetful-inheritance \n       non forgetful inheritance detected.\n You have two solutions: \n       1. (Best practice) Reorganize your hierarchy to make X127 depend on \n       X129 See the paper \"Competing inheritance paths in \n       dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n       explanations \n       2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n       We strongly advise you encapsulate this instance inside a module, \n       in order to isolate it from the rest of the code, and to be able \n       to import it on demand. See the above paper and the file \n       https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n       to witness devastating effects.)) true]",
+                "goal_text": "std.do!\n [if\n   (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n     structure-key X125 _ X126) \n   (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n     (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n     (coq.warning HB HB.non-forgetful-inheritance \n       non forgetful inheritance detected.\n You have two solutions: \n       1. (Best practice) Reorganize your hierarchy to make X127 depend on \n       X129 See the paper \"Competing inheritance paths in \n       dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n       explanations \n       2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n       We strongly advise you encapsulate this instance inside a module, \n       in order to isolate it from the rest of the code, and to be able \n       to import it on demand. See the above paper and the file \n       https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n       to witness devastating effects.)) true]",
                 "goal_id": 1452
               }
             ],
@@ -74318,13 +71829,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 343,
                     "column": 0,
                     "character": 14959
@@ -74605,13 +72114,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -74630,8 +72137,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -74656,13 +72162,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -74677,8 +72181,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -74710,8 +72213,7 @@
       "Inference",
       {
         "current_goal_id": 1452,
-        "current_goal_text":
-          "std.do!\n [if\n   (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n     structure-key X125 _ X126) \n   (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n     (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n     (coq.warning HB HB.non-forgetful-inheritance \n       non forgetful inheritance detected.\n You have two solutions: \n       1. (Best practice) Reorganize your hierarchy to make X127 depend on \n       X129 See the paper \"Competing inheritance paths in \n       dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n       explanations \n       2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n       We strongly advise you encapsulate this instance inside a module, \n       in order to isolate it from the rest of the code, and to be able \n       to import it on demand. See the above paper and the file \n       https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n       to witness devastating effects.)) true]",
+        "current_goal_text": "std.do!\n [if\n   (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n     structure-key X125 _ X126) \n   (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n     (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n     (coq.warning HB HB.non-forgetful-inheritance \n       non forgetful inheritance detected.\n You have two solutions: \n       1. (Best practice) Reorganize your hierarchy to make X127 depend on \n       X129 See the paper \"Competing inheritance paths in \n       dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n       explanations \n       2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n       We strongly advise you encapsulate this instance inside a module, \n       in order to isolate it from the rest of the code, and to be able \n       to import it on demand. See the above paper and the file \n       https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n       to witness devastating effects.)) true]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -74720,8 +72222,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -74743,8 +72244,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if\n (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n   structure-key X125 _ X126) \n (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n   (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n   (coq.warning HB HB.non-forgetful-inheritance \n     non forgetful inheritance detected.\n You have two solutions: \n     1. (Best practice) Reorganize your hierarchy to make X127 depend on \n     X129 See the paper \"Competing inheritance paths in \n     dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n     explanations \n     2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n     We strongly advise you encapsulate this instance inside a module, \n     in order to isolate it from the rest of the code, and to be able \n     to import it on demand. See the above paper and the file \n     https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n     to witness devastating effects.)) true",
+                "goal_text": "if\n (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n   structure-key X125 _ X126) \n (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n   (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n   (coq.warning HB HB.non-forgetful-inheritance \n     non forgetful inheritance detected.\n You have two solutions: \n     1. (Best practice) Reorganize your hierarchy to make X127 depend on \n     X129 See the paper \"Competing inheritance paths in \n     dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n     explanations \n     2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n     We strongly advise you encapsulate this instance inside a module, \n     in order to isolate it from the rest of the code, and to be able \n     to import it on demand. See the above paper and the file \n     https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n     to witness devastating effects.)) true",
                 "goal_id": 1453
               },
               { "goal_text": "!", "goal_id": 1454 },
@@ -74778,13 +72278,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 343,
                     "column": 0,
                     "character": 14959
@@ -75065,13 +72563,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -75090,8 +72586,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -75116,13 +72611,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -75137,8 +72630,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -75170,8 +72662,7 @@
       "Inference",
       {
         "current_goal_id": 1453,
-        "current_goal_text":
-          "if\n (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n   structure-key X125 _ X126) \n (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n   (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n   (coq.warning HB HB.non-forgetful-inheritance \n     non forgetful inheritance detected.\n You have two solutions: \n     1. (Best practice) Reorganize your hierarchy to make X127 depend on \n     X129 See the paper \"Competing inheritance paths in \n     dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n     explanations \n     2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n     We strongly advise you encapsulate this instance inside a module, \n     in order to isolate it from the rest of the code, and to be able \n     to import it on demand. See the above paper and the file \n     https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n     to witness devastating effects.)) true",
+        "current_goal_text": "if\n (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n   structure-key X125 _ X126) \n (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n   (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n   (coq.warning HB HB.non-forgetful-inheritance \n     non forgetful inheritance detected.\n You have two solutions: \n     1. (Best practice) Reorganize your hierarchy to make X127 depend on \n     X129 See the paper \"Competing inheritance paths in \n     dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n     explanations \n     2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n     We strongly advise you encapsulate this instance inside a module, \n     in order to isolate it from the rest of the code, and to be able \n     to import it on demand. See the above paper and the file \n     https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n     to witness devastating effects.)) true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -75205,14 +72696,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n structure-key X125 _ X126",
+                "goal_text": "coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n structure-key X125 _ X126",
                 "goal_id": 1456
               },
               { "goal_text": "!", "goal_id": 1457 },
               {
-                "goal_text":
-                  ", (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n (coq.warning HB HB.non-forgetful-inheritance \n   non forgetful inheritance detected.\n You have two solutions: \n   1. (Best practice) Reorganize your hierarchy to make X127 depend on X129 \n   See the paper \"Competing inheritance paths in \n   dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n   explanations \n   2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n   We strongly advise you encapsulate this instance inside a module, \n   in order to isolate it from the rest of the code, and to be able \n   to import it on demand. See the above paper and the file \n   https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n   to witness devastating effects.)",
+                "goal_text": ", (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n (coq.warning HB HB.non-forgetful-inheritance \n   non forgetful inheritance detected.\n You have two solutions: \n   1. (Best practice) Reorganize your hierarchy to make X127 depend on X129 \n   See the paper \"Competing inheritance paths in \n   dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n   explanations \n   2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n   We strongly advise you encapsulate this instance inside a module, \n   in order to isolate it from the rest of the code, and to be able \n   to import it on demand. See the above paper and the file \n   https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n   to witness devastating effects.)",
                 "goal_id": 1458
               }
             ],
@@ -75263,13 +72752,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 343,
                     "column": 0,
                     "character": 14959
@@ -75550,13 +73037,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -75575,8 +73060,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -75601,13 +73085,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -75622,8 +73104,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -75655,8 +73136,7 @@
       "Inference",
       {
         "current_goal_id": 1456,
-        "current_goal_text":
-          "coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n structure-key X125 _ X126",
+        "current_goal_text": "coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n structure-key X125 _ X126",
         "current_goal_predicate": ",",
         "failed_attempts": [],
         "successful_attempts": [
@@ -75667,8 +73147,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _",
+                "goal_text": "coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _",
                 "goal_id": 1459
               },
               { "goal_text": "structure-key X125 _ X126", "goal_id": 1460 }
@@ -75725,13 +73204,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 343,
                     "column": 0,
                     "character": 14959
@@ -76012,13 +73489,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -76037,8 +73512,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -76063,13 +73537,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -76084,8 +73556,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -76117,8 +73588,7 @@
       "Inference",
       {
         "current_goal_id": 1459,
-        "current_goal_text":
-          "coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _",
+        "current_goal_text": "coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _",
         "current_goal_predicate": "coq.safe-dest-app",
         "failed_attempts": [
           {
@@ -76215,13 +73685,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 343,
                     "column": 0,
                     "character": 14959
@@ -76502,13 +73970,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -76527,8 +73993,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -76553,13 +74018,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -76574,8 +74037,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -76607,8 +74069,7 @@
       "Inference",
       {
         "current_goal_id": 1453,
-        "current_goal_text":
-          "if\n (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n   structure-key X125 _ X126) \n (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n   (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n   (coq.warning HB HB.non-forgetful-inheritance \n     non forgetful inheritance detected.\n You have two solutions: \n     1. (Best practice) Reorganize your hierarchy to make X127 depend on \n     X129 See the paper \"Competing inheritance paths in \n     dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n     explanations \n     2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n     We strongly advise you encapsulate this instance inside a module, \n     in order to isolate it from the rest of the code, and to be able \n     to import it on demand. See the above paper and the file \n     https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n     to witness devastating effects.)) true",
+        "current_goal_text": "if\n (coq.safe-dest-app (global (indt «nat»)) (global (const X125)) _ ,\n   structure-key X125 _ X126) \n (, (nice-gref->string (indt «IsSelfA'.axioms_») X127) \n   (nice-gref->string X126 X128 , calc (X128 ^ .) X129) \n   (coq.warning HB HB.non-forgetful-inheritance \n     non forgetful inheritance detected.\n You have two solutions: \n     1. (Best practice) Reorganize your hierarchy to make X127 depend on \n     X129 See the paper \"Competing inheritance paths in \n     dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n     explanations \n     2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n     We strongly advise you encapsulate this instance inside a module, \n     in order to isolate it from the rest of the code, and to be able \n     to import it on demand. See the above paper and the file \n     https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n     to witness devastating effects.)) true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -76679,13 +74140,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 343,
                     "column": 0,
                     "character": 14959
@@ -76966,13 +74425,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -76991,8 +74448,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -77017,13 +74473,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -77038,8 +74492,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -77161,13 +74614,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 343,
                     "column": 0,
                     "character": 14959
@@ -77448,13 +74899,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -77473,8 +74922,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -77499,13 +74947,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -77520,8 +74966,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -77630,13 +75075,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
+                "rule_text": "(instance.private.check-non-forgetful-inheritance A0 A1) :- (std.do!\n                                                              [if\n                                                                (coq.safe-dest-app\n                                                                  A0 \n                                                                  (global\n                                                                    (\n                                                                    const A2)) \n                                                                  _ ,\n                                                                  structure-key\n                                                                   A2 _ A3) \n                                                                (,\n                                                                  (nice-gref->string\n                                                                    A1 A4) \n                                                                  (nice-gref->string\n                                                                    A3 A5 ,\n                                                                    calc\n                                                                    (A5 ^ .) \n                                                                    A6) \n                                                                  (coq.warning\n                                                                    HB \n                                                                    HB.non-forgetful-inheritance \n                                                                    non forgetful inheritance detected.\n \n                                                                    You have two solutions: \n                                                                    1. (Best practice) Reorganize your hierarchy to make \n                                                                    A4 \n                                                                    depend on \n                                                                    A6 \n                                                                    See the paper \"Competing inheritance paths in \n                                                                    dependent type theory\" (https://hal.inria.fr/hal-02463336) for more \n                                                                    explanations \n                                                                    2. Use the attribute #[non_forgetful_inheritance] to disable this check. \n                                                                    We strongly advise you encapsulate this instance inside a module, \n                                                                    in order to isolate it from the rest of the code, and to be able \n                                                                    to import it on demand. See the above paper and the file \n                                                                    https://github.com/math-comp/hierarchy-builder/blob/master/tests/non-forgetful-inheritance.v \n                                                                    to witness devastating effects.)) \n                                                                true]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 343,
                     "column": 0,
                     "character": 14959
@@ -77917,13 +75360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -77942,8 +75383,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -77968,13 +75408,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -77989,8 +75427,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -78028,8 +75465,7 @@
       "Inference",
       {
         "current_goal_id": 1449,
-        "current_goal_text":
-          "std.do!\n [instance.private.declare-instance (indt «IsSelfA'.axioms_») \n   (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+        "current_goal_text": "std.do!\n [instance.private.declare-instance (indt «IsSelfA'.axioms_») \n   (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90, \n  if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -78038,8 +75474,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -78064,14 +75499,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "instance.private.declare-instance (indt «IsSelfA'.axioms_») \n (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90",
+                "goal_text": "instance.private.declare-instance (indt «IsSelfA'.axioms_») \n (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90",
                 "goal_id": 1462
               },
               { "goal_text": "!", "goal_id": 1463 },
               {
-                "goal_text":
-                  "std.do!\n [if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
+                "goal_text": "std.do!\n [if\n   (arity (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) =\n     arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instance section) ,\n     log.coq.env.end-section-name X76), acc-clauses current X89]",
                 "goal_id": 1464
               }
             ],
@@ -78369,13 +75802,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -78394,8 +75825,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -78420,13 +75850,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -78441,8 +75869,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -78474,8 +75901,7 @@
       "Inference",
       {
         "current_goal_id": 1462,
-        "current_goal_text":
-          "instance.private.declare-instance (indt «IsSelfA'.axioms_») \n (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90",
+        "current_goal_text": "instance.private.declare-instance (indt «IsSelfA'.axioms_») \n (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90",
         "current_goal_predicate": "instance.private.declare-instance",
         "failed_attempts": [],
         "successful_attempts": [
@@ -78484,13 +75910,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (current-mode\n                                                        (builder-from A1 A5 \n                                                          A6 _)), (!), \n (if (get-option local tt) \n   (coq.error\n     HB: declare-instance: cannot make builders local.\n    If you want temporary instances, make an alias, e.g. with let T' := T) \n   true), (!), \n (instance.private.declare-canonical-instances-from-factory-and-local-builders\n   A0 A1 A2 A5 A6 A3 A4).",
+                  "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (current-mode\n                                                        (builder-from A1 A5 \n                                                          A6 _)), (!), \n (if (get-option local tt) \n   (coq.error\n     HB: declare-instance: cannot make builders local.\n    If you want temporary instances, make an alias, e.g. with let T' := T) \n   true), (!), \n (instance.private.declare-canonical-instances-from-factory-and-local-builders\n   A0 A1 A2 A5 A6 A3 A4).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 188,
                       "column": 0,
                       "character": 8025
@@ -78510,20 +75934,17 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "current-mode (builder-from (global (indt «nat»)) X130 X131 _)",
+                "goal_text": "current-mode (builder-from (global (indt «nat»)) X130 X131 _)",
                 "goal_id": 1465
               },
               { "goal_text": "!", "goal_id": 1466 },
               {
-                "goal_text":
-                  "if (get-option local tt) \n (coq.error\n   HB: declare-instance: cannot make builders local.\n    If you want temporary instances, make an alias, e.g. with let T' := T) \n true",
+                "goal_text": "if (get-option local tt) \n (coq.error\n   HB: declare-instance: cannot make builders local.\n    If you want temporary instances, make an alias, e.g. with let T' := T) \n true",
                 "goal_id": 1467
               },
               { "goal_text": "!", "goal_id": 1468 },
               {
-                "goal_text":
-                  "instance.private.declare-canonical-instances-from-factory-and-local-builders\n (indt «IsSelfA'.axioms_») (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) X130 X131 X89 X90",
+                "goal_text": "instance.private.declare-canonical-instances-from-factory-and-local-builders\n (indt «IsSelfA'.axioms_») (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) X130 X131 X89 X90",
                 "goal_id": 1469
               }
             ],
@@ -78536,13 +75957,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (current-mode\n                                                        (builder-from A1 A5 \n                                                          A6 _)), (!), \n (if (get-option local tt) \n   (coq.error\n     HB: declare-instance: cannot make builders local.\n    If you want temporary instances, make an alias, e.g. with let T' := T) \n   true), (!), \n (instance.private.declare-canonical-instances-from-factory-and-local-builders\n   A0 A1 A2 A5 A6 A3 A4).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (current-mode\n                                                        (builder-from A1 A5 \n                                                          A6 _)), (!), \n (if (get-option local tt) \n   (coq.error\n     HB: declare-instance: cannot make builders local.\n    If you want temporary instances, make an alias, e.g. with let T' := T) \n   true), (!), \n (instance.private.declare-canonical-instances-from-factory-and-local-builders\n   A0 A1 A2 A5 A6 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 188,
                     "column": 0,
                     "character": 8025
@@ -78842,13 +76261,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -78867,8 +76284,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -78893,13 +76309,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -78914,8 +76328,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -78947,8 +76360,7 @@
       "Inference",
       {
         "current_goal_id": 1465,
-        "current_goal_text":
-          "current-mode (builder-from (global (indt «nat»)) X130 X131 _)",
+        "current_goal_text": "current-mode (builder-from (global (indt «nat»)) X130 X131 _)",
         "current_goal_predicate": "current-mode",
         "failed_attempts": [],
         "successful_attempts": [],
@@ -78958,13 +76370,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (current-mode\n                                                        (builder-from A1 A5 \n                                                          A6 _)), (!), \n (if (get-option local tt) \n   (coq.error\n     HB: declare-instance: cannot make builders local.\n    If you want temporary instances, make an alias, e.g. with let T' := T) \n   true), (!), \n (instance.private.declare-canonical-instances-from-factory-and-local-builders\n   A0 A1 A2 A5 A6 A3 A4).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (current-mode\n                                                        (builder-from A1 A5 \n                                                          A6 _)), (!), \n (if (get-option local tt) \n   (coq.error\n     HB: declare-instance: cannot make builders local.\n    If you want temporary instances, make an alias, e.g. with let T' := T) \n   true), (!), \n (instance.private.declare-canonical-instances-from-factory-and-local-builders\n   A0 A1 A2 A5 A6 A3 A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 188,
                     "column": 0,
                     "character": 8025
@@ -79264,13 +76674,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -79289,8 +76697,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -79315,13 +76722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -79336,8 +76741,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -79369,8 +76773,7 @@
       "Inference",
       {
         "current_goal_id": 1462,
-        "current_goal_text":
-          "instance.private.declare-instance (indt «IsSelfA'.axioms_») \n (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90",
+        "current_goal_text": "instance.private.declare-instance (indt «IsSelfA'.axioms_») \n (global (indt «nat»)) (global (const «HB_unnamed_factory_27»)) X89 X90",
         "current_goal_predicate": "instance.private.declare-instance",
         "failed_attempts": [],
         "successful_attempts": [
@@ -79379,13 +76782,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                  "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 196,
                       "column": 0,
                       "character": 8410
@@ -79405,13 +76806,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "instance.private.declare-canonical-instances-from-factory\n (indt «IsSelfA'.axioms_») (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) X90",
+                "goal_text": "instance.private.declare-canonical-instances-from-factory\n (indt «IsSelfA'.axioms_») (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) X90",
                 "goal_id": 1470
               },
               {
-                "goal_text":
-                  "if (get-option export tt) \n (coq.env.current-library X132 ,\n   std.map X90 (c0 \\ c1 \\\n    sigma c2 \\ sigma c3 \\ c0 = pr c2 c3 , c1 = instance-to-export X132 c2 c3) \n    X89) (X89 = [])",
+                "goal_text": "if (get-option export tt) \n (coq.env.current-library X132 ,\n   std.map X90 (c0 \\ c1 \\\n    sigma c2 \\ sigma c3 \\ c0 = pr c2 c3 , c1 = instance-to-export X132 c2 c3) \n    X89) (X89 = [])",
                 "goal_id": 1471
               }
             ],
@@ -79424,13 +76823,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -79730,13 +77127,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -79755,8 +77150,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -79781,13 +77175,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -79802,8 +77194,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -79835,10 +77226,8 @@
       "Inference",
       {
         "current_goal_id": 1470,
-        "current_goal_text":
-          "instance.private.declare-canonical-instances-from-factory\n (indt «IsSelfA'.axioms_») (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) X90",
-        "current_goal_predicate":
-          "instance.private.declare-canonical-instances-from-factory",
+        "current_goal_text": "instance.private.declare-canonical-instances-from-factory\n (indt «IsSelfA'.axioms_») (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) X90",
+        "current_goal_predicate": "instance.private.declare-canonical-instances-from-factory",
         "failed_attempts": [],
         "successful_attempts": [
           {
@@ -79846,13 +77235,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                  "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                       "line": 282,
                       "column": 0,
                       "character": 12180
@@ -79871,8 +77258,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [synthesis.under-mixin-src-from-factory.do! (global (indt «nat»)) \n   (global (const «HB_unnamed_factory_27»)) \n   [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n     [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n        list-w-params_list X133 X134), \n      instance.private.add-all-mixins (global (indt «nat»)) \n       (indt «IsSelfA'.axioms_») X134 tt _ X135, \n      (findall-classes-for X134 X136 ,\n        instance.declare-all (global (indt «nat»)) X136 X137)]], \n  std.append X135 X137 X90]",
+                "goal_text": "std.do!\n [synthesis.under-mixin-src-from-factory.do! (global (indt «nat»)) \n   (global (const «HB_unnamed_factory_27»)) \n   [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n     [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n        list-w-params_list X133 X134), \n      instance.private.add-all-mixins (global (indt «nat»)) \n       (indt «IsSelfA'.axioms_») X134 tt _ X135, \n      (findall-classes-for X134 X136 ,\n        instance.declare-all (global (indt «nat»)) X136 X137)]], \n  std.append X135 X137 X90]",
                 "goal_id": 1472
               }
             ],
@@ -79885,13 +77271,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -79906,13 +77290,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -80212,13 +77594,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -80237,8 +77617,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -80263,13 +77642,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -80284,8 +77661,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -80317,8 +77693,7 @@
       "Inference",
       {
         "current_goal_id": 1472,
-        "current_goal_text":
-          "std.do!\n [synthesis.under-mixin-src-from-factory.do! (global (indt «nat»)) \n   (global (const «HB_unnamed_factory_27»)) \n   [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n     [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n        list-w-params_list X133 X134), \n      instance.private.add-all-mixins (global (indt «nat»)) \n       (indt «IsSelfA'.axioms_») X134 tt _ X135, \n      (findall-classes-for X134 X136 ,\n        instance.declare-all (global (indt «nat»)) X136 X137)]], \n  std.append X135 X137 X90]",
+        "current_goal_text": "std.do!\n [synthesis.under-mixin-src-from-factory.do! (global (indt «nat»)) \n   (global (const «HB_unnamed_factory_27»)) \n   [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n     [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n        list-w-params_list X133 X134), \n      instance.private.add-all-mixins (global (indt «nat»)) \n       (indt «IsSelfA'.axioms_») X134 tt _ X135, \n      (findall-classes-for X134 X136 ,\n        instance.declare-all (global (indt «nat»)) X136 X137)]], \n  std.append X135 X137 X90]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -80327,8 +77702,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -80350,8 +77724,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "synthesis.under-mixin-src-from-factory.do! (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) \n [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n   [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n      list-w-params_list X133 X134), \n    instance.private.add-all-mixins (global (indt «nat»)) \n     (indt «IsSelfA'.axioms_») X134 tt _ X135, \n    (findall-classes-for X134 X136 ,\n      instance.declare-all (global (indt «nat»)) X136 X137)]]",
+                "goal_text": "synthesis.under-mixin-src-from-factory.do! (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) \n [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n   [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n      list-w-params_list X133 X134), \n    instance.private.add-all-mixins (global (indt «nat»)) \n     (indt «IsSelfA'.axioms_») X134 tt _ X135, \n    (findall-classes-for X134 X136 ,\n      instance.declare-all (global (indt «nat»)) X136 X137)]]",
                 "goal_id": 1473
               },
               { "goal_text": "!", "goal_id": 1474 },
@@ -80388,13 +77761,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -80409,13 +77780,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -80715,13 +78084,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -80740,8 +78107,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -80766,13 +78132,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -80787,8 +78151,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -80820,10 +78183,8 @@
       "Inference",
       {
         "current_goal_id": 1473,
-        "current_goal_text":
-          "synthesis.under-mixin-src-from-factory.do! (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) \n [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n   [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n      list-w-params_list X133 X134), \n    instance.private.add-all-mixins (global (indt «nat»)) \n     (indt «IsSelfA'.axioms_») X134 tt _ X135, \n    (findall-classes-for X134 X136 ,\n      instance.declare-all (global (indt «nat»)) X136 X137)]]",
-        "current_goal_predicate":
-          "synthesis.under-mixin-src-from-factory.do!",
+        "current_goal_text": "synthesis.under-mixin-src-from-factory.do! (global (indt «nat»)) \n (global (const «HB_unnamed_factory_27»)) \n [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n   [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n      list-w-params_list X133 X134), \n    instance.private.add-all-mixins (global (indt «nat»)) \n     (indt «IsSelfA'.axioms_») X134 tt _ X135, \n    (findall-classes-for X134 X136 ,\n      instance.declare-all (global (indt «nat»)) X136 X137)]]",
+        "current_goal_predicate": "synthesis.under-mixin-src-from-factory.do!",
         "failed_attempts": [],
         "successful_attempts": [
           {
@@ -80831,13 +78192,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                  "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                       "line": 100,
                       "column": 0,
                       "character": 4390
@@ -80858,8 +78217,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [synthesis.private.factory-instance->new-mixins [] \n   (global (const «HB_unnamed_factory_27»)) X138, \n  std.map X138 (c0 \\ c1 \\\n   c1 =\n    mixin-src (global (indt «nat»)) c0 \n     (global (const «HB_unnamed_factory_27»))) X139, \n  X139 =>\n   std.do!\n    [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n      [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n         list-w-params_list X133 X134), \n       instance.private.add-all-mixins (global (indt «nat»)) \n        (indt «IsSelfA'.axioms_») X134 tt _ X135, \n       (findall-classes-for X134 X136 ,\n         instance.declare-all (global (indt «nat»)) X136 X137)]]]",
+                "goal_text": "std.do!\n [synthesis.private.factory-instance->new-mixins [] \n   (global (const «HB_unnamed_factory_27»)) X138, \n  std.map X138 (c0 \\ c1 \\\n   c1 =\n    mixin-src (global (indt «nat»)) c0 \n     (global (const «HB_unnamed_factory_27»))) X139, \n  X139 =>\n   std.do!\n    [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n      [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n         list-w-params_list X133 X134), \n       instance.private.add-all-mixins (global (indt «nat»)) \n        (indt «IsSelfA'.axioms_») X134 tt _ X135, \n       (findall-classes-for X134 X136 ,\n         instance.declare-all (global (indt «nat»)) X136 X137)]]]",
                 "goal_id": 1476
               }
             ],
@@ -80872,13 +78230,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -80912,13 +78268,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -80933,13 +78287,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -81239,13 +78591,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -81264,8 +78614,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -81290,13 +78639,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -81311,8 +78658,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -81344,8 +78690,7 @@
       "Inference",
       {
         "current_goal_id": 1476,
-        "current_goal_text":
-          "std.do!\n [synthesis.private.factory-instance->new-mixins [] \n   (global (const «HB_unnamed_factory_27»)) X138, \n  std.map X138 (c0 \\ c1 \\\n   c1 =\n    mixin-src (global (indt «nat»)) c0 \n     (global (const «HB_unnamed_factory_27»))) X139, \n  X139 =>\n   std.do!\n    [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n      [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n         list-w-params_list X133 X134), \n       instance.private.add-all-mixins (global (indt «nat»)) \n        (indt «IsSelfA'.axioms_») X134 tt _ X135, \n       (findall-classes-for X134 X136 ,\n         instance.declare-all (global (indt «nat»)) X136 X137)]]]",
+        "current_goal_text": "std.do!\n [synthesis.private.factory-instance->new-mixins [] \n   (global (const «HB_unnamed_factory_27»)) X138, \n  std.map X138 (c0 \\ c1 \\\n   c1 =\n    mixin-src (global (indt «nat»)) c0 \n     (global (const «HB_unnamed_factory_27»))) X139, \n  X139 =>\n   std.do!\n    [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n      [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n         list-w-params_list X133 X134), \n       instance.private.add-all-mixins (global (indt «nat»)) \n        (indt «IsSelfA'.axioms_») X134 tt _ X135, \n       (findall-classes-for X134 X136 ,\n         instance.declare-all (global (indt «nat»)) X136 X137)]]]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -81354,8 +78699,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -81380,14 +78724,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "synthesis.private.factory-instance->new-mixins [] \n (global (const «HB_unnamed_factory_27»)) X138",
+                "goal_text": "synthesis.private.factory-instance->new-mixins [] \n (global (const «HB_unnamed_factory_27»)) X138",
                 "goal_id": 1477
               },
               { "goal_text": "!", "goal_id": 1478 },
               {
-                "goal_text":
-                  "std.do!\n [std.map X138 (c0 \\ c1 \\\n   c1 =\n    mixin-src (global (indt «nat»)) c0 \n     (global (const «HB_unnamed_factory_27»))) X139, \n  X139 =>\n   std.do!\n    [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n      [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n         list-w-params_list X133 X134), \n       instance.private.add-all-mixins (global (indt «nat»)) \n        (indt «IsSelfA'.axioms_») X134 tt _ X135, \n       (findall-classes-for X134 X136 ,\n         instance.declare-all (global (indt «nat»)) X136 X137)]]]",
+                "goal_text": "std.do!\n [std.map X138 (c0 \\ c1 \\\n   c1 =\n    mixin-src (global (indt «nat»)) c0 \n     (global (const «HB_unnamed_factory_27»))) X139, \n  X139 =>\n   std.do!\n    [synthesis.under-local-canonical-mixins-of.do! (global (indt «nat»)) \n      [(factory-provides (indt «IsSelfA'.axioms_») X133 ,\n         list-w-params_list X133 X134), \n       instance.private.add-all-mixins (global (indt «nat»)) \n        (indt «IsSelfA'.axioms_») X134 tt _ X135, \n       (findall-classes-for X134 X136 ,\n         instance.declare-all (global (indt «nat»)) X136 X137)]]]",
                 "goal_id": 1479
               }
             ],
@@ -81419,13 +78761,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -81459,13 +78799,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -81480,13 +78818,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -81786,13 +79122,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -81811,8 +79145,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -81837,13 +79170,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -81858,8 +79189,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -81891,10 +79221,8 @@
       "Inference",
       {
         "current_goal_id": 1477,
-        "current_goal_text":
-          "synthesis.private.factory-instance->new-mixins [] \n (global (const «HB_unnamed_factory_27»)) X138",
-        "current_goal_predicate":
-          "synthesis.private.factory-instance->new-mixins",
+        "current_goal_text": "synthesis.private.factory-instance->new-mixins [] \n (global (const «HB_unnamed_factory_27»)) X138",
+        "current_goal_predicate": "synthesis.private.factory-instance->new-mixins",
         "failed_attempts": [],
         "successful_attempts": [
           {
@@ -81902,13 +79230,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                  "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                       "line": 289,
                       "column": 0,
                       "character": 12694
@@ -81926,8 +79252,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n   mixin-src: X illtyped, \n  if (not (coq.safe-dest-app X140 (global _) _)) \n   (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n     (coq.term->string X140 X142) \n     (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true, \n  coq.term->gref X140 X143, factory-provides X143 X144, \n  list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
+                "goal_text": "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n   mixin-src: X illtyped, \n  if (not (coq.safe-dest-app X140 (global _) _)) \n   (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n     (coq.term->string X140 X142) \n     (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true, \n  coq.term->gref X140 X143, factory-provides X143 X144, \n  list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
                 "goal_id": 1480
               }
             ],
@@ -81940,13 +79265,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -81980,13 +79303,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -82020,13 +79341,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -82041,13 +79360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -82347,13 +79664,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -82372,8 +79687,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -82398,13 +79712,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -82419,8 +79731,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -82452,8 +79763,7 @@
       "Inference",
       {
         "current_goal_id": 1480,
-        "current_goal_text":
-          "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n   mixin-src: X illtyped, \n  if (not (coq.safe-dest-app X140 (global _) _)) \n   (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n     (coq.term->string X140 X142) \n     (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true, \n  coq.term->gref X140 X143, factory-provides X143 X144, \n  list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
+        "current_goal_text": "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n   mixin-src: X illtyped, \n  if (not (coq.safe-dest-app X140 (global _) _)) \n   (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n     (coq.term->string X140 X142) \n     (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true, \n  coq.term->gref X140 X143, factory-provides X143 X144, \n  list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -82462,8 +79772,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -82488,14 +79797,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.assert-ok!\n (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n mixin-src: X illtyped",
+                "goal_text": "std.assert-ok!\n (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n mixin-src: X illtyped",
                 "goal_id": 1481
               },
               { "goal_text": "!", "goal_id": 1482 },
               {
-                "goal_text":
-                  "std.do!\n [if (not (coq.safe-dest-app X140 (global _) _)) \n   (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n     (coq.term->string X140 X142) \n     (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true, \n  coq.term->gref X140 X143, factory-provides X143 X144, \n  list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
+                "goal_text": "std.do!\n [if (not (coq.safe-dest-app X140 (global _) _)) \n   (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n     (coq.term->string X140 X142) \n     (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true, \n  coq.term->gref X140 X143, factory-provides X143 X144, \n  list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
                 "goal_id": 1483
               }
             ],
@@ -82527,13 +79834,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -82567,13 +79872,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -82607,13 +79910,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -82628,13 +79929,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -82934,13 +80233,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -82959,8 +80256,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -82985,13 +80281,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -83006,8 +80300,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -83039,8 +80332,7 @@
       "Inference",
       {
         "current_goal_id": 1481,
-        "current_goal_text":
-          "std.assert-ok!\n (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n mixin-src: X illtyped",
+        "current_goal_text": "std.assert-ok!\n (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n mixin-src: X illtyped",
         "current_goal_predicate": "std.assert-ok!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -83049,8 +80341,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                  "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -83072,14 +80363,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.typecheck (global (const «HB_unnamed_factory_27»)) X140 X146",
+                "goal_text": "coq.typecheck (global (const «HB_unnamed_factory_27»)) X140 X146",
                 "goal_id": 1484
               },
               { "goal_text": "!", "goal_id": 1485 },
               {
-                "goal_text":
-                  "X146 = ok ;\n X146 = error X147 , std.fatal-error-w-data mixin-src: X illtyped X147",
+                "goal_text": "X146 = ok ;\n X146 = error X147 , std.fatal-error-w-data mixin-src: X illtyped X147",
                 "goal_id": 1486
               },
               { "goal_text": "!", "goal_id": 1487 }
@@ -83093,8 +80382,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -83132,13 +80420,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -83172,13 +80458,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -83212,13 +80496,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -83233,13 +80515,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -83539,13 +80819,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -83564,8 +80842,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -83590,13 +80867,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -83611,8 +80886,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -83644,8 +80918,7 @@
       "Inference",
       {
         "current_goal_id": 1484,
-        "current_goal_text":
-          "coq.typecheck (global (const «HB_unnamed_factory_27»)) X140 X146",
+        "current_goal_text": "coq.typecheck (global (const «HB_unnamed_factory_27»)) X140 X146",
         "current_goal_predicate": "coq.typecheck",
         "failed_attempts": [],
         "successful_attempts": [
@@ -83656,8 +80929,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X140 = app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]",
+                "goal_text": "X140 = app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]",
                 "goal_id": 1488
               },
               { "goal_text": "X146 = ok", "goal_id": 1489 }
@@ -83676,8 +80948,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -83715,13 +80986,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -83755,13 +81024,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -83795,13 +81062,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -83816,13 +81081,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -84122,13 +81385,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -84147,8 +81408,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -84173,13 +81433,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -84194,8 +81452,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -84227,8 +81484,7 @@
       "Inference",
       {
         "current_goal_id": 1488,
-        "current_goal_text":
-          "X140 = app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]",
+        "current_goal_text": "X140 = app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -84262,8 +81518,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -84301,13 +81556,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -84341,13 +81594,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -84381,13 +81632,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -84402,13 +81651,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -84708,13 +81955,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -84733,8 +81978,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -84759,13 +82003,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -84780,8 +82022,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -84842,8 +82083,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -84881,13 +82121,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -84921,13 +82159,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -84961,13 +82197,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -84982,13 +82216,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -85288,13 +82520,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -85313,8 +82543,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -85339,13 +82568,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -85360,8 +82587,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -85396,13 +82622,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.assert-ok!\n (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n mixin-src: X illtyped",
+              "goal_text": "std.assert-ok!\n (coq.typecheck (global (const «HB_unnamed_factory_27»)) X140) \n mixin-src: X illtyped",
               "goal_id": 1481
             },
             "cut_branch": {
-              "rule_text":
-                "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
+              "rule_text": "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
               "rule_loc": [
                 "File",
                 {
@@ -85426,8 +82650,7 @@
       "Inference",
       {
         "current_goal_id": 1486,
-        "current_goal_text":
-          "ok = ok ; ok = error X147 , std.fatal-error-w-data mixin-src: X illtyped X147",
+        "current_goal_text": "ok = ok ; ok = error X147 , std.fatal-error-w-data mixin-src: X illtyped X147",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -85479,8 +82702,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -85518,13 +82740,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -85558,13 +82778,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -85598,13 +82816,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -85619,13 +82835,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -85925,13 +83139,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -85950,8 +83162,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -85976,13 +83187,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -85997,8 +83206,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -86073,8 +83281,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -86112,13 +83319,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -86152,13 +83357,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -86192,13 +83395,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -86213,13 +83414,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -86519,13 +83718,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -86544,8 +83741,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -86570,13 +83766,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -86591,8 +83785,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -86627,8 +83820,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "X146 = ok ;\n X146 = error X147 , std.fatal-error-w-data mixin-src: X illtyped X147",
+              "goal_text": "X146 = ok ;\n X146 = error X147 , std.fatal-error-w-data mixin-src: X illtyped X147",
               "goal_id": 1486
             },
             "cut_branch": {
@@ -86662,8 +83854,7 @@
       "Inference",
       {
         "current_goal_id": 1483,
-        "current_goal_text":
-          "std.do!\n [if\n   (not\n     (coq.safe-dest-app\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n       (global _) _)) \n   (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n     (coq.term->string\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n     (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true, \n  coq.term->gref\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143, \n  factory-provides X143 X144, list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
+        "current_goal_text": "std.do!\n [if\n   (not\n     (coq.safe-dest-app\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n       (global _) _)) \n   (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n     (coq.term->string\n       (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n     (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true, \n  coq.term->gref\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143, \n  factory-provides X143 X144, list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -86672,8 +83863,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -86698,14 +83888,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if\n (not\n   (coq.safe-dest-app\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n     (global _) _)) \n (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n   (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true",
+                "goal_text": "if\n (not\n   (coq.safe-dest-app\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n     (global _) _)) \n (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n   (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true",
                 "goal_id": 1491
               },
               { "goal_text": "!", "goal_id": 1492 },
               {
-                "goal_text":
-                  "std.do!\n [coq.term->gref\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143, \n  factory-provides X143 X144, list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
+                "goal_text": "std.do!\n [coq.term->gref\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143, \n  factory-provides X143 X144, list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
                 "goal_id": 1493
               }
             ],
@@ -86756,13 +83944,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -86796,13 +83982,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -86836,13 +84020,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -86857,13 +84039,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -87163,13 +84343,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -87188,8 +84366,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -87214,13 +84391,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -87235,8 +84410,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -87268,8 +84442,7 @@
       "Inference",
       {
         "current_goal_id": 1491,
-        "current_goal_text":
-          "if\n (not\n   (coq.safe-dest-app\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n     (global _) _)) \n (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n   (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true",
+        "current_goal_text": "if\n (not\n   (coq.safe-dest-app\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n     (global _) _)) \n (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n   (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -87303,14 +84476,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "not\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global _) _)",
+                "goal_text": "not\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global _) _)",
                 "goal_id": 1494
               },
               { "goal_text": "!", "goal_id": 1495 },
               {
-                "goal_text":
-                  ", (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n (coq.term->string\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)",
+                "goal_text": ", (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n (coq.term->string\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)",
                 "goal_id": 1496
               }
             ],
@@ -87380,13 +84551,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -87420,13 +84589,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -87460,13 +84627,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -87481,13 +84646,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -87787,13 +84950,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -87812,8 +84973,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -87838,13 +84998,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -87859,8 +85017,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -87892,8 +85049,7 @@
       "Inference",
       {
         "current_goal_id": 1494,
-        "current_goal_text":
-          "not\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global _) _)",
+        "current_goal_text": "not\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global _) _)",
         "current_goal_predicate": "not",
         "failed_attempts": [],
         "successful_attempts": [
@@ -87923,8 +85079,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global _) _",
+                "goal_text": "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global _) _",
                 "goal_id": 1497
               },
               { "goal_text": "!", "goal_id": 1498 },
@@ -88015,13 +85170,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -88055,13 +85208,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -88095,13 +85246,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -88116,13 +85265,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -88422,13 +85569,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -88447,8 +85592,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -88473,13 +85617,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -88494,8 +85636,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -88527,8 +85668,7 @@
       "Inference",
       {
         "current_goal_id": 1497,
-        "current_goal_text":
-          "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global _) _",
+        "current_goal_text": "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global _) _",
         "current_goal_predicate": "coq.safe-dest-app",
         "failed_attempts": [],
         "successful_attempts": [
@@ -88537,8 +85677,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
+                  "rule_text": "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
                   "rule_loc": [
                     "File",
                     {
@@ -88559,8 +85698,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1500 },
               {
-                "goal_text":
-                  "coq.safe-dest-app (global (indt «IsSelfA'.axioms_»)) (global _) X148",
+                "goal_text": "coq.safe-dest-app (global (indt «IsSelfA'.axioms_»)) (global _) X148",
                 "goal_id": 1501
               },
               {
@@ -88577,8 +85715,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
+                "rule_text": "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -88673,13 +85810,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -88713,13 +85848,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -88753,13 +85886,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -88774,13 +85905,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -89080,13 +86209,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -89105,8 +86232,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -89131,13 +86257,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -89152,8 +86276,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -89188,8 +86311,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global _) _",
+              "goal_text": "coq.safe-dest-app\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n (global _) _",
               "goal_id": 1497
             },
             "cut_branch": {
@@ -89217,8 +86339,7 @@
       "Inference",
       {
         "current_goal_id": 1501,
-        "current_goal_text":
-          "coq.safe-dest-app (global (indt «IsSelfA'.axioms_»)) (global _) X148",
+        "current_goal_text": "coq.safe-dest-app (global (indt «IsSelfA'.axioms_»)) (global _) X148",
         "current_goal_predicate": "coq.safe-dest-app",
         "failed_attempts": [],
         "successful_attempts": [
@@ -89273,8 +86394,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
+                "rule_text": "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -89369,13 +86489,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -89409,13 +86527,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -89449,13 +86565,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -89470,13 +86584,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -89776,13 +86888,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -89801,8 +86911,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -89827,13 +86936,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -89848,8 +86955,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -89936,8 +87042,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
+                "rule_text": "(coq.safe-dest-app (app [A0 | A1]) A2 A3) :- (!), \n (coq.safe-dest-app A0 A2 A4), (std.append A4 A1 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -90032,13 +87137,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -90072,13 +87175,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -90112,13 +87213,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -90133,13 +87232,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -90439,13 +87536,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -90464,8 +87559,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -90490,13 +87584,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -90511,8 +87603,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -90547,8 +87638,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "not\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global _) _)",
+              "goal_text": "not\n (coq.safe-dest-app\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n   (global _) _)",
               "goal_id": 1494
             },
             "cut_branch": {
@@ -90662,13 +87752,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -90702,13 +87790,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -90742,13 +87828,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -90763,13 +87847,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -91069,13 +88151,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -91094,8 +88174,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -91120,13 +88199,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -91141,8 +88218,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -91174,8 +88250,7 @@
       "Inference",
       {
         "current_goal_id": 1491,
-        "current_goal_text":
-          "if\n (not\n   (coq.safe-dest-app\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n     (global _) _)) \n (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n   (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true",
+        "current_goal_text": "if\n (not\n   (coq.safe-dest-app\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) \n     (global _) _)) \n (, (coq.term->string (global (const «HB_unnamed_factory_27»)) X141) \n   (coq.term->string\n     (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X142) \n   (coq.error Term:\n X141 \nhas type:\n X142 \nwhich is not a record)) true",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -91265,13 +88340,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -91305,13 +88378,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -91345,13 +88416,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -91366,13 +88435,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -91672,13 +88739,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -91697,8 +88762,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -91723,13 +88787,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -91744,8 +88806,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -91886,13 +88947,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -91926,13 +88985,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -91966,13 +89023,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -91987,13 +89042,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -92293,13 +89346,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -92318,8 +89369,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -92344,13 +89394,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -92365,8 +89413,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -92404,8 +89451,7 @@
       "Inference",
       {
         "current_goal_id": 1493,
-        "current_goal_text":
-          "std.do!\n [coq.term->gref\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143, \n  factory-provides X143 X144, list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
+        "current_goal_text": "std.do!\n [coq.term->gref\n   (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143, \n  factory-provides X143 X144, list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -92414,8 +89460,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -92440,14 +89485,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.term->gref\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143",
+                "goal_text": "coq.term->gref\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143",
                 "goal_id": 1504
               },
               { "goal_text": "!", "goal_id": 1505 },
               {
-                "goal_text":
-                  "std.do!\n [factory-provides X143 X144, list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
+                "goal_text": "std.do!\n [factory-provides X143 X144, list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
                 "goal_id": 1506
               }
             ],
@@ -92517,13 +89560,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -92557,13 +89598,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -92597,13 +89636,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -92618,13 +89655,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -92924,13 +89959,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -92949,8 +89982,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -92975,13 +90007,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -92996,8 +90026,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -93029,8 +90058,7 @@
       "Inference",
       {
         "current_goal_id": 1504,
-        "current_goal_text":
-          "coq.term->gref\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143",
+        "current_goal_text": "coq.term->gref\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143",
         "current_goal_predicate": "coq.term->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -93039,8 +90067,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(coq.term->gref (app [A0 | _]) A1) :- (!), (coq.term->gref A0 A1).",
+                  "rule_text": "(coq.term->gref (app [A0 | _]) A1) :- (!), (coq.term->gref A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -93060,8 +90087,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1507 },
               {
-                "goal_text":
-                  "coq.term->gref (global (indt «IsSelfA'.axioms_»)) X143",
+                "goal_text": "coq.term->gref (global (indt «IsSelfA'.axioms_»)) X143",
                 "goal_id": 1508
               }
             ],
@@ -93074,8 +90100,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.term->gref (app [A0 | _]) A1) :- (!), (coq.term->gref A0 A1).",
+                "rule_text": "(coq.term->gref (app [A0 | _]) A1) :- (!), (coq.term->gref A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -93151,13 +90176,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -93191,13 +90214,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -93231,13 +90252,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -93252,13 +90271,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -93558,13 +90575,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -93583,8 +90598,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -93609,13 +90623,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -93630,8 +90642,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -93666,13 +90677,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "coq.term->gref\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143",
+              "goal_text": "coq.term->gref\n (app [global (indt «IsSelfA'.axioms_»), global (indt «nat»)]) X143",
               "goal_id": 1504
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.term->gref A0 _) :- (std.fatal-error-w-data\n                           term->gref: input has no global reference A0).",
+              "rule_text": "(coq.term->gref A0 _) :- (std.fatal-error-w-data\n                           term->gref: input has no global reference A0).",
               "rule_loc": [
                 "File",
                 {
@@ -93696,8 +90705,7 @@
       "Inference",
       {
         "current_goal_id": 1508,
-        "current_goal_text":
-          "coq.term->gref (global (indt «IsSelfA'.axioms_»)) X143",
+        "current_goal_text": "coq.term->gref (global (indt «IsSelfA'.axioms_»)) X143",
         "current_goal_predicate": "coq.term->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -93752,8 +90760,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.term->gref (app [A0 | _]) A1) :- (!), (coq.term->gref A0 A1).",
+                "rule_text": "(coq.term->gref (app [A0 | _]) A1) :- (!), (coq.term->gref A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -93829,13 +90836,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -93869,13 +90874,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -93909,13 +90912,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -93930,13 +90931,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -94236,13 +91235,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -94261,8 +91258,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -94287,13 +91283,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -94308,8 +91302,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -94344,13 +91337,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "coq.term->gref (global (indt «IsSelfA'.axioms_»)) X143",
+              "goal_text": "coq.term->gref (global (indt «IsSelfA'.axioms_»)) X143",
               "goal_id": 1508
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.term->gref A0 _) :- (std.fatal-error-w-data\n                           term->gref: input has no global reference A0).",
+              "rule_text": "(coq.term->gref A0 _) :- (std.fatal-error-w-data\n                           term->gref: input has no global reference A0).",
               "rule_loc": [
                 "File",
                 {
@@ -94380,8 +91371,7 @@
       "Inference",
       {
         "current_goal_id": 1506,
-        "current_goal_text":
-          "std.do!\n [factory-provides (indt «IsSelfA'.axioms_») X144, \n  list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
+        "current_goal_text": "std.do!\n [factory-provides (indt «IsSelfA'.axioms_») X144, \n  list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -94390,8 +91380,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -94416,14 +91405,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "factory-provides (indt «IsSelfA'.axioms_») X144",
+                "goal_text": "factory-provides (indt «IsSelfA'.axioms_») X144",
                 "goal_id": 1510
               },
               { "goal_text": "!", "goal_id": 1511 },
               {
-                "goal_text":
-                  "std.do!\n [list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
+                "goal_text": "std.do!\n [list-w-params_list X144 X145, \n  std.filter X145 (c0 \\ not (std.mem! [] c0)) X138]",
                 "goal_id": 1512
               }
             ],
@@ -94512,13 +91499,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -94552,13 +91537,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -94592,13 +91575,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -94613,13 +91594,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -94919,13 +91898,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -94944,8 +91921,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -94970,13 +91946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -94991,8 +91965,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -95024,8 +91997,7 @@
       "Inference",
       {
         "current_goal_id": 1510,
-        "current_goal_text":
-          "factory-provides (indt «IsSelfA'.axioms_») X144",
+        "current_goal_text": "factory-provides (indt «IsSelfA'.axioms_») X144",
         "current_goal_predicate": "factory-provides",
         "failed_attempts": [],
         "successful_attempts": [
@@ -95034,13 +92006,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                  "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 86,
                       "column": 0,
                       "character": 2829
@@ -95055,8 +92025,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [factory-alias->gref (indt «IsSelfA'.axioms_») X150, gref-deps X150 X151, \n  w-params.map X151 (factory-provides.base X150) X144]",
+                "goal_text": "std.do!\n [factory-alias->gref (indt «IsSelfA'.axioms_») X150, gref-deps X150 X151, \n  w-params.map X151 (factory-provides.base X150) X144]",
                 "goal_id": 1513
               }
             ],
@@ -95069,13 +92038,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -95166,13 +92133,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -95206,13 +92171,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -95246,13 +92209,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -95267,13 +92228,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -95573,13 +92532,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -95598,8 +92555,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -95624,13 +92580,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -95645,8 +92599,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -95678,8 +92631,7 @@
       "Inference",
       {
         "current_goal_id": 1513,
-        "current_goal_text":
-          "std.do!\n [factory-alias->gref (indt «IsSelfA'.axioms_») X150, gref-deps X150 X151, \n  w-params.map X151 (factory-provides.base X150) X144]",
+        "current_goal_text": "std.do!\n [factory-alias->gref (indt «IsSelfA'.axioms_») X150, gref-deps X150 X151, \n  w-params.map X151 (factory-provides.base X150) X144]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -95688,8 +92640,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -95714,14 +92665,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
+                "goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
                 "goal_id": 1514
               },
               { "goal_text": "!", "goal_id": 1515 },
               {
-                "goal_text":
-                  "std.do!\n [gref-deps X150 X151, w-params.map X151 (factory-provides.base X150) X144]",
+                "goal_text": "std.do!\n [gref-deps X150 X151, w-params.map X151 (factory-provides.base X150) X144]",
                 "goal_id": 1516
               }
             ],
@@ -95753,13 +92702,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -95850,13 +92797,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -95890,13 +92835,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -95930,13 +92873,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -95951,13 +92892,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -96257,13 +93196,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -96282,8 +93219,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -96308,13 +93244,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -96329,8 +93263,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -96362,8 +93295,7 @@
       "Inference",
       {
         "current_goal_id": 1514,
-        "current_goal_text":
-          "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
+        "current_goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
         "current_goal_predicate": "factory-alias->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -96372,13 +93304,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                  "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 74,
                       "column": 0,
                       "character": 2385
@@ -96393,8 +93323,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "phant-abbrev X150 (indt «IsSelfA'.axioms_») _",
+                "goal_text": "phant-abbrev X150 (indt «IsSelfA'.axioms_») _",
                 "goal_id": 1517
               },
               { "goal_text": "!", "goal_id": 1518 }
@@ -96408,13 +93337,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 74,
                     "column": 0,
                     "character": 2385
@@ -96448,13 +93375,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -96545,13 +93470,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -96585,13 +93508,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -96625,13 +93546,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -96646,13 +93565,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -96952,13 +93869,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -96977,8 +93892,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -97003,13 +93917,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -97024,8 +93936,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -97057,16 +93968,14 @@
       "Inference",
       {
         "current_goal_id": 1517,
-        "current_goal_text":
-          "phant-abbrev X150 (indt «IsSelfA'.axioms_») _",
+        "current_goal_text": "phant-abbrev X150 (indt «IsSelfA'.axioms_») _",
         "current_goal_predicate": "phant-abbrev",
         "failed_attempts": [
           {
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -97090,8 +93999,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -97115,8 +94023,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -97140,8 +94047,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -97165,8 +94071,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -97190,8 +94095,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -97215,8 +94119,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -97240,8 +94143,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -97269,8 +94171,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -97289,13 +94190,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 74,
                     "column": 0,
                     "character": 2385
@@ -97329,13 +94228,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -97426,13 +94323,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -97466,13 +94361,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -97506,13 +94399,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -97527,13 +94418,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -97833,13 +94722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -97858,8 +94745,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -97884,13 +94770,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -97905,8 +94789,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -97938,8 +94821,7 @@
       "Inference",
       {
         "current_goal_id": 1514,
-        "current_goal_text":
-          "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
+        "current_goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
         "current_goal_predicate": "factory-alias->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -97948,13 +94830,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                  "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 75,
                       "column": 0,
                       "character": 2443
@@ -97983,13 +94863,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2443
@@ -98023,13 +94901,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -98120,13 +94996,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -98160,13 +95034,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -98200,13 +95072,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -98221,13 +95091,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -98527,13 +95395,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -98552,8 +95418,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -98578,13 +95443,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -98599,8 +95462,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -98639,8 +95501,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -98663,8 +95524,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -98687,8 +95547,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -98709,8 +95568,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                  "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                   "rule_loc": [
                     "File",
                     {
@@ -98739,8 +95597,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -98759,13 +95616,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2443
@@ -98799,13 +95654,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -98896,13 +95749,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -98936,13 +95787,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -98976,13 +95825,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -98997,13 +95844,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -99303,13 +96148,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -99328,8 +96171,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -99354,13 +96196,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -99375,8 +96215,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -99411,13 +96250,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
+              "goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
               "goal_id": 1514
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «A.axioms_») (indt «A.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «A.axioms_») (indt «A.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -99431,13 +96268,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
+              "goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
               "goal_id": 1514
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «B.axioms_») (indt «B.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «B.axioms_») (indt «B.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -99451,13 +96286,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
+              "goal_text": "factory-alias->gref (indt «IsSelfA'.axioms_») X150",
               "goal_id": 1514
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «SelfA.axioms_») (indt «SelfA.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «SelfA.axioms_») (indt «SelfA.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -99487,8 +96320,7 @@
       "Inference",
       {
         "current_goal_id": 1516,
-        "current_goal_text":
-          "std.do!\n [gref-deps (indt «IsSelfA'.axioms_») X151, \n  w-params.map X151 (factory-provides.base (indt «IsSelfA'.axioms_»)) X144]",
+        "current_goal_text": "std.do!\n [gref-deps (indt «IsSelfA'.axioms_») X151, \n  w-params.map X151 (factory-provides.base (indt «IsSelfA'.axioms_»)) X144]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -99497,8 +96329,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -99528,8 +96359,7 @@
               },
               { "goal_text": "!", "goal_id": 1522 },
               {
-                "goal_text":
-                  "std.do!\n [w-params.map X151 (factory-provides.base (indt «IsSelfA'.axioms_»)) X144]",
+                "goal_text": "std.do!\n [w-params.map X151 (factory-provides.base (indt «IsSelfA'.axioms_»)) X144]",
                 "goal_id": 1523
               }
             ],
@@ -99580,13 +96410,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -99677,13 +96505,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -99717,13 +96543,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -99757,13 +96581,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -99778,13 +96600,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -100084,13 +96904,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -100109,8 +96927,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -100135,13 +96952,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -100156,8 +96971,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -100198,8 +97012,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(gref-deps (indt «IsSelfA'.axioms_») \n  (w-params.nil TheType (sort (typ «interleave_context.382»)) (c0 \\ []))) :- .",
+                  "rule_text": "(gref-deps (indt «IsSelfA'.axioms_») \n  (w-params.nil TheType (sort (typ «interleave_context.382»)) (c0 \\ []))) :- .",
                   "rule_loc": [
                     "File",
                     {
@@ -100228,8 +97041,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(gref-deps (indt «IsSelfA'.axioms_») \n  (w-params.nil TheType (sort (typ «interleave_context.382»)) (c0 \\ []))) :- .",
+                "rule_text": "(gref-deps (indt «IsSelfA'.axioms_») \n  (w-params.nil TheType (sort (typ «interleave_context.382»)) (c0 \\ []))) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -100286,13 +97098,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -100383,13 +97193,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -100423,13 +97231,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -100463,13 +97269,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -100484,13 +97288,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -100790,13 +97592,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -100815,8 +97615,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -100841,13 +97640,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -100862,8 +97659,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -100901,8 +97697,7 @@
       "Inference",
       {
         "current_goal_id": 1523,
-        "current_goal_text":
-          "std.do!\n [w-params.map\n   (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n   (factory-provides.base (indt «IsSelfA'.axioms_»)) X144]",
+        "current_goal_text": "std.do!\n [w-params.map\n   (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n   (factory-provides.base (indt «IsSelfA'.axioms_»)) X144]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -100911,8 +97706,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -100934,8 +97728,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "w-params.map\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n (factory-provides.base (indt «IsSelfA'.axioms_»)) X144",
+                "goal_text": "w-params.map\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n (factory-provides.base (indt «IsSelfA'.axioms_»)) X144",
                 "goal_id": 1524
               },
               { "goal_text": "!", "goal_id": 1525 },
@@ -101007,13 +97800,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -101104,13 +97895,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -101144,13 +97933,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -101184,13 +97971,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -101205,13 +97990,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -101511,13 +98294,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -101536,8 +98317,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -101562,13 +98342,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -101583,8 +98361,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -101616,8 +98393,7 @@
       "Inference",
       {
         "current_goal_id": 1524,
-        "current_goal_text":
-          "w-params.map\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n (factory-provides.base (indt «IsSelfA'.axioms_»)) X144",
+        "current_goal_text": "w-params.map\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n (factory-provides.base (indt «IsSelfA'.axioms_»)) X144",
         "current_goal_predicate": "w-params.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -101626,13 +98402,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                  "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 245,
                       "column": 0,
                       "character": 9440
@@ -101654,8 +98428,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "w-params.then\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name mk-w-params.nil-name \n (factory-provides.base (indt «IsSelfA'.axioms_»)) X144",
+                "goal_text": "w-params.then\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name mk-w-params.nil-name \n (factory-provides.base (indt «IsSelfA'.axioms_»)) X144",
                 "goal_id": 1527
               }
             ],
@@ -101668,13 +98441,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -101746,13 +98517,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -101843,13 +98612,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -101883,13 +98650,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -101923,13 +98688,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -101944,13 +98707,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -102250,13 +99011,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -102275,8 +99034,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -102301,13 +99059,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -102322,8 +99078,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -102355,8 +99110,7 @@
       "Inference",
       {
         "current_goal_id": 1527,
-        "current_goal_text":
-          "w-params.then\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name mk-w-params.nil-name \n (factory-provides.base (indt «IsSelfA'.axioms_»)) X144",
+        "current_goal_text": "w-params.then\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name mk-w-params.nil-name \n (factory-provides.base (indt «IsSelfA'.axioms_»)) X144",
         "current_goal_predicate": "w-params.then",
         "failed_attempts": [],
         "successful_attempts": [
@@ -102365,13 +99119,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                  "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 239,
                       "column": 0,
                       "character": 9183
@@ -102395,8 +99147,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "w-params.fold\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name (c0 \\ c1 \\ c2 \\ c3 \\ c4 \\\n sigma c5 \\\n  pi c6 \\\n   decl c6 c1 c2 =>\n    factory-provides.base (indt «IsSelfA'.axioms_») c0 c6 (c3 c6) (c5 c6) ,\n   mk-w-params.nil-name c1 c2 c5 c4) X144",
+                "goal_text": "w-params.fold\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name (c0 \\ c1 \\ c2 \\ c3 \\ c4 \\\n sigma c5 \\\n  pi c6 \\\n   decl c6 c1 c2 =>\n    factory-provides.base (indt «IsSelfA'.axioms_») c0 c6 (c3 c6) (c5 c6) ,\n   mk-w-params.nil-name c1 c2 c5 c4) X144",
                 "goal_id": 1528
               }
             ],
@@ -102409,13 +99160,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -102430,13 +99179,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -102508,13 +99255,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -102605,13 +99350,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -102645,13 +99388,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -102685,13 +99426,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -102706,13 +99445,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -103012,13 +99749,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -103037,8 +99772,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -103063,13 +99797,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -103084,8 +99816,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -103117,8 +99848,7 @@
       "Inference",
       {
         "current_goal_id": 1528,
-        "current_goal_text":
-          "w-params.fold\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name (c0 \\ c1 \\ c2 \\ c3 \\ c4 \\\n sigma c5 \\\n  pi c6 \\\n   decl c6 c1 c2 =>\n    factory-provides.base (indt «IsSelfA'.axioms_») c0 c6 (c3 c6) (c5 c6) ,\n   mk-w-params.nil-name c1 c2 c5 c4) X144",
+        "current_goal_text": "w-params.fold\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name (c0 \\ c1 \\ c2 \\ c3 \\ c4 \\\n sigma c5 \\\n  pi c6 \\\n   decl c6 c1 c2 =>\n    factory-provides.base (indt «IsSelfA'.axioms_») c0 c6 (c3 c6) (c5 c6) ,\n   mk-w-params.nil-name c1 c2 c5 c4) X144",
         "current_goal_predicate": "w-params.fold",
         "failed_attempts": [],
         "successful_attempts": [
@@ -103127,13 +99857,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                  "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 213,
                       "column": 0,
                       "character": 8143
@@ -103156,8 +99884,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "w-params.fold.params\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name (c0 \\ c1 \\ c2 \\ c3 \\ c4 \\\n sigma c5 \\\n  pi c6 \\\n   decl c6 c1 c2 =>\n    factory-provides.base (indt «IsSelfA'.axioms_») c0 c6 (c3 c6) (c5 c6) ,\n   mk-w-params.nil-name c1 c2 c5 c4) [] X144",
+                "goal_text": "w-params.fold.params\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name (c0 \\ c1 \\ c2 \\ c3 \\ c4 \\\n sigma c5 \\\n  pi c6 \\\n   decl c6 c1 c2 =>\n    factory-provides.base (indt «IsSelfA'.axioms_») c0 c6 (c3 c6) (c5 c6) ,\n   mk-w-params.nil-name c1 c2 c5 c4) [] X144",
                 "goal_id": 1529
               }
             ],
@@ -103170,13 +99897,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -103191,13 +99916,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -103212,13 +99935,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -103290,13 +100011,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -103387,13 +100106,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -103427,13 +100144,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -103467,13 +100182,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -103488,13 +100201,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -103794,13 +100505,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -103819,8 +100528,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -103845,13 +100553,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -103866,8 +100572,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -103899,8 +100604,7 @@
       "Inference",
       {
         "current_goal_id": 1529,
-        "current_goal_text":
-          "w-params.fold.params\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name (c0 \\ c1 \\ c2 \\ c3 \\ c4 \\\n sigma c5 \\\n  pi c6 \\\n   decl c6 c1 c2 =>\n    factory-provides.base (indt «IsSelfA'.axioms_») c0 c6 (c3 c6) (c5 c6) ,\n   mk-w-params.nil-name c1 c2 c5 c4) [] X144",
+        "current_goal_text": "w-params.fold.params\n (w-params.nil TheType (sort (typ «interleave_context.382»)) c0 \\ []) \n mk-w-params.cons-name (c0 \\ c1 \\ c2 \\ c3 \\ c4 \\\n sigma c5 \\\n  pi c6 \\\n   decl c6 c1 c2 =>\n    factory-provides.base (indt «IsSelfA'.axioms_») c0 c6 (c3 c6) (c5 c6) ,\n   mk-w-params.nil-name c1 c2 c5 c4) [] X144",
         "current_goal_predicate": "w-params.fold.params",
         "failed_attempts": [],
         "successful_attempts": [
@@ -103909,13 +100613,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                  "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 224,
                       "column": 0,
                       "character": 8609
@@ -103938,8 +100640,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1530 },
               {
-                "goal_text":
-                  "std.do!\n [coq.id->name TheType X152, std.rev [] X153, \n  sigma c0 \\\n   pi c1 \\\n    decl c1 X152 (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name X152 (sort (typ «interleave_context.382»)) c0 X144]",
+                "goal_text": "std.do!\n [coq.id->name TheType X152, std.rev [] X153, \n  sigma c0 \\\n   pi c1 \\\n    decl c1 X152 (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name X152 (sort (typ «interleave_context.382»)) c0 X144]",
                 "goal_id": 1531
               }
             ],
@@ -103952,13 +100653,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -103973,13 +100672,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -103994,13 +100691,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -104015,13 +100710,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -104093,13 +100786,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -104190,13 +100881,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -104230,13 +100919,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -104270,13 +100957,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -104291,13 +100976,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -104597,13 +101280,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -104622,8 +101303,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -104648,13 +101328,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -104669,8 +101347,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -104708,8 +101385,7 @@
       "Inference",
       {
         "current_goal_id": 1531,
-        "current_goal_text":
-          "std.do!\n [coq.id->name TheType X152, std.rev [] X153, \n  sigma c0 \\\n   pi c1 \\\n    decl c1 X152 (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name X152 (sort (typ «interleave_context.382»)) c0 X144]",
+        "current_goal_text": "std.do!\n [coq.id->name TheType X152, std.rev [] X153, \n  sigma c0 \\\n   pi c1 \\\n    decl c1 X152 (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name X152 (sort (typ «interleave_context.382»)) c0 X144]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -104718,8 +101394,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -104743,8 +101418,7 @@
               { "goal_text": "coq.id->name TheType X152", "goal_id": 1532 },
               { "goal_text": "!", "goal_id": 1533 },
               {
-                "goal_text":
-                  "std.do!\n [std.rev [] X153, \n  sigma c0 \\\n   pi c1 \\\n    decl c1 X152 (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name X152 (sort (typ «interleave_context.382»)) c0 X144]",
+                "goal_text": "std.do!\n [std.rev [] X153, \n  sigma c0 \\\n   pi c1 \\\n    decl c1 X152 (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name X152 (sort (typ «interleave_context.382»)) c0 X144]",
                 "goal_id": 1534
               }
             ],
@@ -104776,13 +101450,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -104797,13 +101469,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -104818,13 +101488,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -104839,13 +101507,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -104917,13 +101583,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -105014,13 +101678,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -105054,13 +101716,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -105094,13 +101754,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -105115,13 +101773,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -105421,13 +102077,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -105446,8 +102100,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -105472,13 +102125,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -105493,8 +102144,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -105535,8 +102185,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(coq.id->name A0 A1) :- (coq.string->name A0 A1).",
+                  "rule_text": "(coq.id->name A0 A1) :- (coq.string->name A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -105549,8 +102198,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := TheType" ],
-                [ "Assign", "A1 := X152" ]
+                [ "Assign", "A0 := TheType" ], [ "Assign", "A1 := X152" ]
               ]
             },
             "siblings": [
@@ -105568,8 +102216,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.id->name A0 A1) :- (coq.string->name A0 A1).",
+                "rule_text": "(coq.id->name A0 A1) :- (coq.string->name A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -105607,13 +102254,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -105628,13 +102273,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -105649,13 +102292,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -105670,13 +102311,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -105748,13 +102387,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -105845,13 +102482,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -105885,13 +102520,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -105925,13 +102558,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -105946,13 +102577,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -106252,13 +102881,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -106277,8 +102904,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -106303,13 +102929,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -106324,8 +102948,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -106383,8 +103006,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.id->name A0 A1) :- (coq.string->name A0 A1).",
+                "rule_text": "(coq.id->name A0 A1) :- (coq.string->name A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -106422,13 +103044,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -106443,13 +103063,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -106464,13 +103082,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -106485,13 +103101,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -106563,13 +103177,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -106660,13 +103272,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -106700,13 +103310,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -106740,13 +103348,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -106761,13 +103367,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -107067,13 +103671,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -107092,8 +103694,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -107118,13 +103719,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -107139,8 +103738,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -107201,8 +103799,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.id->name A0 A1) :- (coq.string->name A0 A1).",
+                "rule_text": "(coq.id->name A0 A1) :- (coq.string->name A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -107240,13 +103837,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -107261,13 +103856,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -107282,13 +103875,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -107303,13 +103894,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -107381,13 +103970,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -107478,13 +104065,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -107518,13 +104103,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -107558,13 +104141,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -107579,13 +104160,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -107885,13 +104464,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -107910,8 +104487,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -107936,13 +104512,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -107957,8 +104531,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -107996,8 +104569,7 @@
       "Inference",
       {
         "current_goal_id": 1534,
-        "current_goal_text":
-          "std.do!\n [std.rev [] X153, \n  sigma c0 \\\n   pi c1 \\\n    decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) \n     c0 X144]",
+        "current_goal_text": "std.do!\n [std.rev [] X153, \n  sigma c0 \\\n   pi c1 \\\n    decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) \n     c0 X144]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -108006,8 +104578,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -108031,8 +104602,7 @@
               { "goal_text": "std.rev [] X153", "goal_id": 1537 },
               { "goal_text": "!", "goal_id": 1538 },
               {
-                "goal_text":
-                  "std.do!\n [sigma c0 \\\n   pi c1 \\\n    decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) \n     c0 X144]",
+                "goal_text": "std.do!\n [sigma c0 \\\n   pi c1 \\\n    decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») X153 c1 [] (c0 c1) ,\n    mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) \n     c0 X144]",
                 "goal_id": 1539
               }
             ],
@@ -108083,13 +104653,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -108104,13 +104672,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -108125,13 +104691,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -108146,13 +104710,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -108224,13 +104786,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -108321,13 +104881,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -108361,13 +104919,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -108401,13 +104957,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -108422,13 +104976,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -108728,13 +105280,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -108753,8 +105303,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -108779,13 +105328,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -108800,8 +105347,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -108855,8 +105401,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := []" ],
-                [ "Assign", "A1 := X153" ]
+                [ "Assign", "A0 := []" ], [ "Assign", "A1 := X153" ]
               ]
             },
             "siblings": [
@@ -108928,13 +105473,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -108949,13 +105492,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -108970,13 +105511,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -108991,13 +105530,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -109069,13 +105606,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -109166,13 +105701,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -109206,13 +105739,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -109246,13 +105777,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -109267,13 +105796,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -109573,13 +106100,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -109598,8 +106123,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -109624,13 +106148,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -109645,8 +106167,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -109700,8 +106221,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := []" ],
-                [ "Assign", "X153 := []" ]
+                [ "Assign", "A0 := []" ], [ "Assign", "X153 := []" ]
               ]
             },
             "siblings": [],
@@ -109790,13 +106310,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -109811,13 +106329,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -109832,13 +106348,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -109853,13 +106367,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -109931,13 +106443,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -110028,13 +106538,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -110068,13 +106576,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -110108,13 +106614,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -110129,13 +106633,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -110435,13 +106937,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -110460,8 +106960,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -110486,13 +106985,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -110507,8 +107004,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -110546,8 +107042,7 @@
       "Inference",
       {
         "current_goal_id": 1539,
-        "current_goal_text":
-          "std.do!\n [sigma c0 \\\n   pi c1 \\\n    decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») [] c1 [] (c0 c1) ,\n    mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) \n     c0 X144]",
+        "current_goal_text": "std.do!\n [sigma c0 \\\n   pi c1 \\\n    decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n     factory-provides.base (indt «IsSelfA'.axioms_») [] c1 [] (c0 c1) ,\n    mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) \n     c0 X144]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -110556,8 +107051,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -110579,8 +107073,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "sigma c0 \\\n pi c1 \\\n  decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n   factory-provides.base (indt «IsSelfA'.axioms_») [] c1 [] (c0 c1) ,\n  mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) c0 \n   X144",
+                "goal_text": "sigma c0 \\\n pi c1 \\\n  decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n   factory-provides.base (indt «IsSelfA'.axioms_») [] c1 [] (c0 c1) ,\n  mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) c0 \n   X144",
                 "goal_id": 1541
               },
               { "goal_text": "!", "goal_id": 1542 },
@@ -110652,13 +107145,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -110673,13 +107164,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -110694,13 +107183,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -110715,13 +107202,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -110793,13 +107278,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -110890,13 +107373,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -110930,13 +107411,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -110970,13 +107449,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -110991,13 +107468,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -111297,13 +107772,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -111322,8 +107795,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -111348,13 +107820,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -111369,8 +107839,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -111402,8 +107871,7 @@
       "Inference",
       {
         "current_goal_id": 1541,
-        "current_goal_text":
-          "sigma c0 \\\n pi c1 \\\n  decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n   factory-provides.base (indt «IsSelfA'.axioms_») [] c1 [] (c0 c1) ,\n  mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) c0 \n   X144",
+        "current_goal_text": "sigma c0 \\\n pi c1 \\\n  decl c1 `TheType` (sort (typ «interleave_context.382»)) =>\n   factory-provides.base (indt «IsSelfA'.axioms_») [] c1 [] (c0 c1) ,\n  mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) c0 \n   X144",
         "current_goal_predicate": "sigma",
         "failed_attempts": [],
         "successful_attempts": [
@@ -111414,8 +107882,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "pi c0 \\\n decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n  factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0) ,\n mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) X154 \n  X144",
+                "goal_text": "pi c0 \\\n decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n  factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0) ,\n mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) X154 \n  X144",
                 "goal_id": 1544
               }
             ],
@@ -111490,13 +107957,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -111511,13 +107976,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -111532,13 +107995,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -111553,13 +108014,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -111631,13 +108090,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -111728,13 +108185,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -111768,13 +108223,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -111808,13 +108261,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -111829,13 +108280,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -112135,13 +108584,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -112160,8 +108607,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -112186,13 +108632,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -112207,8 +108651,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -112240,8 +108683,7 @@
       "Inference",
       {
         "current_goal_id": 1544,
-        "current_goal_text":
-          "pi c0 \\\n decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n  factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0) ,\n mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) X154 \n  X144",
+        "current_goal_text": "pi c0 \\\n decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n  factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0) ,\n mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) X154 \n  X144",
         "current_goal_predicate": ",",
         "failed_attempts": [],
         "successful_attempts": [
@@ -112252,13 +108694,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "pi c0 \\\n decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n  factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
+                "goal_text": "pi c0 \\\n decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n  factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
                 "goal_id": 1545
               },
               {
-                "goal_text":
-                  "mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) X154 \n X144",
+                "goal_text": "mk-w-params.nil-name `TheType` (sort (typ «interleave_context.382»)) X154 \n X144",
                 "goal_id": 1546
               }
             ],
@@ -112338,13 +108778,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -112359,13 +108797,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -112380,13 +108816,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -112401,13 +108835,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -112479,13 +108911,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -112576,13 +109006,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -112616,13 +109044,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -112656,13 +109082,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -112677,13 +109101,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -112983,13 +109405,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -113008,8 +109428,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -113034,13 +109453,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -113055,8 +109472,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -113088,8 +109504,7 @@
       "Inference",
       {
         "current_goal_id": 1545,
-        "current_goal_text":
-          "pi c0 \\\n decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n  factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
+        "current_goal_text": "pi c0 \\\n decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n  factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
         "current_goal_predicate": "pi",
         "failed_attempts": [],
         "successful_attempts": [
@@ -113100,8 +109515,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
+                "goal_text": "decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
                 "goal_id": 1547
               }
             ],
@@ -113186,13 +109600,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -113207,13 +109619,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -113228,13 +109638,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -113249,13 +109657,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -113327,13 +109733,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -113424,13 +109828,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -113464,13 +109866,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -113504,13 +109904,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -113525,13 +109923,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -113831,13 +110227,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -113856,8 +110250,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -113882,13 +110275,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -113903,8 +110294,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -113936,8 +110326,7 @@
       "Inference",
       {
         "current_goal_id": 1547,
-        "current_goal_text":
-          "decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
+        "current_goal_text": "decl c0 `TheType` (sort (typ «interleave_context.382»)) =>\n factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -113948,8 +110337,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
+                "goal_text": "factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
                 "goal_id": 1548
               }
             ],
@@ -114039,13 +110427,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -114060,13 +110446,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -114081,13 +110465,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -114102,13 +110484,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -114180,13 +110560,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -114277,13 +110655,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -114317,13 +110693,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -114357,13 +110731,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -114378,13 +110750,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -114684,13 +111054,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -114709,8 +111077,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -114735,13 +111102,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -114756,8 +111121,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -114789,8 +111153,7 @@
       "Inference",
       {
         "current_goal_id": 1548,
-        "current_goal_text":
-          "factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
+        "current_goal_text": "factory-provides.base (indt «IsSelfA'.axioms_») [] c0 [] (X154 c0)",
         "current_goal_predicate": "factory-provides.base",
         "failed_attempts": [],
         "successful_attempts": [
@@ -114799,13 +111162,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                  "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 100,
                       "column": 0,
                       "character": 3290
@@ -114822,8 +111183,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [std.findall (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1, \n  std.map X157^1 from_mixin X158^1, std.map X157^1 from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
+                "goal_text": "std.do!\n [std.findall (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1, \n  std.map X157^1 from_mixin X158^1, std.map X157^1 from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
                 "goal_id": 1549
               }
             ],
@@ -114836,13 +111196,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -114934,13 +111292,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -114955,13 +111311,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -114976,13 +111330,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -114997,13 +111349,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -115075,13 +111425,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -115172,13 +111520,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -115212,13 +111558,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -115252,13 +111596,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -115273,13 +111615,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -115579,13 +111919,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -115604,8 +111942,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -115630,13 +111967,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -115651,8 +111986,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -115684,8 +112018,7 @@
       "Inference",
       {
         "current_goal_id": 1549,
-        "current_goal_text":
-          "std.do!\n [std.findall (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1, \n  std.map X157^1 from_mixin X158^1, std.map X157^1 from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
+        "current_goal_text": "std.do!\n [std.findall (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1, \n  std.map X157^1 from_mixin X158^1, std.map X157^1 from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -115694,8 +112027,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -115720,14 +112052,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.findall (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1",
+                "goal_text": "std.findall (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1",
                 "goal_id": 1550
               },
               { "goal_text": "!", "goal_id": 1551 },
               {
-                "goal_text":
-                  "std.do!\n [std.map X157^1 from_mixin X158^1, std.map X157^1 from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
+                "goal_text": "std.do!\n [std.map X157^1 from_mixin X158^1, std.map X157^1 from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
                 "goal_id": 1552
               }
             ],
@@ -115759,13 +112089,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -115857,13 +112185,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -115878,13 +112204,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -115899,13 +112223,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -115920,13 +112242,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -115998,13 +112318,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -116095,13 +112413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -116135,13 +112451,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -116175,13 +112489,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -116196,13 +112508,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -116502,13 +112812,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -116527,8 +112835,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -116553,13 +112860,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -116574,8 +112879,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -116607,8 +112911,7 @@
       "Inference",
       {
         "current_goal_id": 1550,
-        "current_goal_text":
-          "std.findall (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1",
+        "current_goal_text": "std.findall (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1",
         "current_goal_predicate": "std.findall",
         "failed_attempts": [],
         "successful_attempts": [
@@ -116617,8 +112920,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                  "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -116640,8 +112942,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "findall_solutions (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1",
+                "goal_text": "findall_solutions (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1",
                 "goal_id": 1553
               }
             ],
@@ -116654,8 +112955,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -116693,13 +112993,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -116791,13 +113089,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -116812,13 +113108,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -116833,13 +113127,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -116854,13 +113146,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -116932,13 +113222,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -117029,13 +113317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -117069,13 +113355,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -117109,13 +113393,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -117130,13 +113412,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -117436,13 +113716,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -117461,8 +113739,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -117487,13 +113764,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -117508,8 +113783,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -117541,8 +113815,7 @@
       "Findall",
       {
         "findall_goal_id": 1553,
-        "findall_goal_text":
-          "findall_solutions (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1",
+        "findall_goal_text": "findall_solutions (from (indt «IsSelfA'.axioms_») X155^1 X156^1) X157^1",
         "findall_cards": [
           {
             "step_id": 0,
@@ -117563,16 +113836,14 @@
               "Inference",
               {
                 "current_goal_id": 1555,
-                "current_goal_text":
-                  "from (indt «IsSelfA'.axioms_») X0^1 X1^1",
+                "current_goal_text": "from (indt «IsSelfA'.axioms_») X0^1 X1^1",
                 "current_goal_predicate": "from",
                 "failed_attempts": [
                   {
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «A.axioms_») (indt «HasA.axioms_») \n  (const «A.interleave_context_HasA_mixin»)) :- .",
+                        "rule_text": "(from (indt «A.axioms_») (indt «HasA.axioms_») \n  (const «A.interleave_context_HasA_mixin»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117595,8 +113866,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «HasB.axioms_») (indt «HasB.axioms_») \n  (const «HasB.identity_builder»)) :- .",
+                        "rule_text": "(from (indt «HasB.axioms_») (indt «HasB.axioms_») \n  (const «HasB.identity_builder»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117619,8 +113889,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «B.axioms_») (indt «HasB.axioms_») \n  (const «B.interleave_context_HasB_mixin»)) :- .",
+                        "rule_text": "(from (indt «B.axioms_») (indt «HasB.axioms_») \n  (const «B.interleave_context_HasB_mixin»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117643,8 +113912,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «IsSelfA.axioms_») (indt «IsSelfA.axioms_») \n  (const «IsSelfA.identity_builder»)) :- .",
+                        "rule_text": "(from (indt «IsSelfA.axioms_») (indt «IsSelfA.axioms_») \n  (const «IsSelfA.identity_builder»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117667,8 +113935,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «SelfA.axioms_») (indt «HasA.axioms_») \n  (const «SelfA.interleave_context_HasA_mixin»)) :- .",
+                        "rule_text": "(from (indt «SelfA.axioms_») (indt «HasA.axioms_») \n  (const «SelfA.interleave_context_HasA_mixin»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117691,8 +113958,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «SelfA.axioms_») (indt «HasB.axioms_») \n  (const «SelfA.interleave_context_HasB_mixin»)) :- .",
+                        "rule_text": "(from (indt «SelfA.axioms_») (indt «HasB.axioms_») \n  (const «SelfA.interleave_context_HasB_mixin»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117715,8 +113981,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «SelfA.axioms_») (indt «IsSelfA.axioms_») \n  (const «SelfA.interleave_context_IsSelfA_mixin»)) :- .",
+                        "rule_text": "(from (indt «SelfA.axioms_») (indt «IsSelfA.axioms_») \n  (const «SelfA.interleave_context_IsSelfA_mixin»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117739,8 +114004,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n  (const «Builders_18.HB_unnamed_factory_24»)) :- .",
+                        "rule_text": "(from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n  (const «Builders_18.HB_unnamed_factory_24»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117767,8 +114031,7 @@
                       "rule": [
                         "UserRule",
                         {
-                          "rule_text":
-                            "(from (indt «HasA.axioms_») (indt «HasA.axioms_») \n  (const «HasA.identity_builder»)) :- .",
+                          "rule_text": "(from (indt «HasA.axioms_») (indt «HasA.axioms_») \n  (const «HasA.identity_builder»)) :- .",
                           "rule_loc": [
                             "File",
                             {
@@ -117797,8 +114060,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «HasA.axioms_») (indt «HasA.axioms_») \n  (const «HasA.identity_builder»)) :- .",
+                        "rule_text": "(from (indt «HasA.axioms_») (indt «HasA.axioms_») \n  (const «HasA.identity_builder»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117825,8 +114087,7 @@
               "Inference",
               {
                 "current_goal_id": 1555,
-                "current_goal_text":
-                  "from (indt «IsSelfA'.axioms_») X0^1 X1^1",
+                "current_goal_text": "from (indt «IsSelfA'.axioms_») X0^1 X1^1",
                 "current_goal_predicate": "from",
                 "failed_attempts": [],
                 "successful_attempts": [
@@ -117835,8 +114096,7 @@
                       "rule": [
                         "UserRule",
                         {
-                          "rule_text":
-                            "(from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n  (const «Builders_18.HB_unnamed_factory_22»)) :- .",
+                          "rule_text": "(from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n  (const «Builders_18.HB_unnamed_factory_22»)) :- .",
                           "rule_loc": [
                             "File",
                             {
@@ -117866,8 +114126,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n  (const «Builders_18.HB_unnamed_factory_22»)) :- .",
+                        "rule_text": "(from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n  (const «Builders_18.HB_unnamed_factory_22»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117894,8 +114153,7 @@
               "Inference",
               {
                 "current_goal_id": 1555,
-                "current_goal_text":
-                  "from (indt «IsSelfA'.axioms_») X0^1 X1^1",
+                "current_goal_text": "from (indt «IsSelfA'.axioms_») X0^1 X1^1",
                 "current_goal_predicate": "from",
                 "failed_attempts": [],
                 "successful_attempts": [
@@ -117904,8 +114162,7 @@
                       "rule": [
                         "UserRule",
                         {
-                          "rule_text":
-                            "(from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n  (const «Builders_18.HB_unnamed_factory_20»)) :- .",
+                          "rule_text": "(from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n  (const «Builders_18.HB_unnamed_factory_20»)) :- .",
                           "rule_loc": [
                             "File",
                             {
@@ -117935,8 +114192,7 @@
                     "rule": [
                       "UserRule",
                       {
-                        "rule_text":
-                          "(from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n  (const «Builders_18.HB_unnamed_factory_20»)) :- .",
+                        "rule_text": "(from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n  (const «Builders_18.HB_unnamed_factory_20»)) :- .",
                         "rule_loc": [
                           "File",
                           {
@@ -117970,8 +114226,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -118009,13 +114264,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -118107,13 +114360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -118128,13 +114379,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -118149,13 +114398,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -118170,13 +114417,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -118248,13 +114493,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -118345,13 +114588,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -118385,13 +114626,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -118425,13 +114664,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -118446,13 +114683,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -118752,13 +114987,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -118777,8 +115010,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -118803,13 +115035,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -118824,8 +115054,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -118863,8 +115092,7 @@
       "Inference",
       {
         "current_goal_id": 1552,
-        "current_goal_text":
-          "std.do!\n [std.map\n   [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_24»), \n    from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n     (const «Builders_18.HB_unnamed_factory_22»), \n    from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X158^1, \n  std.map\n   [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_24»), \n    from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n     (const «Builders_18.HB_unnamed_factory_22»), \n    from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
+        "current_goal_text": "std.do!\n [std.map\n   [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_24»), \n    from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n     (const «Builders_18.HB_unnamed_factory_22»), \n    from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X158^1, \n  std.map\n   [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_24»), \n    from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n     (const «Builders_18.HB_unnamed_factory_22»), \n    from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -118873,8 +115101,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -118899,14 +115126,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.map\n [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»), \n  from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X158^1",
+                "goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»), \n  from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X158^1",
                 "goal_id": 1556
               },
               { "goal_text": "!", "goal_id": 1557 },
               {
-                "goal_text":
-                  "std.do!\n [std.map\n   [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_24»), \n    from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n     (const «Builders_18.HB_unnamed_factory_22»), \n    from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
+                "goal_text": "std.do!\n [std.map\n   [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_24»), \n    from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n     (const «Builders_18.HB_unnamed_factory_22»), \n    from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1, \n  std.map2 X159^1 X158^1 (factory-provides.one [] c0) (X154 c0)]",
                 "goal_id": 1558
               }
             ],
@@ -118957,13 +115182,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -119055,13 +115278,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -119076,13 +115297,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -119097,13 +115316,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -119118,13 +115335,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -119196,13 +115411,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -119293,13 +115506,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -119333,13 +115544,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -119373,13 +115582,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -119394,13 +115601,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -119700,13 +115905,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -119725,8 +115928,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -119751,13 +115953,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -119772,8 +115972,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -119805,8 +116004,7 @@
       "Inference",
       {
         "current_goal_id": 1556,
-        "current_goal_text":
-          "std.map\n [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»), \n  from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X158^1",
+        "current_goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»), \n  from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X158^1",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -119815,8 +116013,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -119843,13 +116040,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»)) X160^1",
+                "goal_text": "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»)) X160^1",
                 "goal_id": 1559
               },
               {
-                "goal_text":
-                  "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X161^1",
+                "goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X161^1",
                 "goal_id": 1560
               }
             ],
@@ -119862,8 +116057,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -119920,13 +116114,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -120018,13 +116210,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -120039,13 +116229,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -120060,13 +116248,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -120081,13 +116267,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -120159,13 +116343,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -120256,13 +116438,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -120296,13 +116476,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -120336,13 +116514,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -120357,13 +116533,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -120663,13 +116837,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -120688,8 +116860,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -120714,13 +116885,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -120735,8 +116904,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -120768,8 +116936,7 @@
       "Inference",
       {
         "current_goal_id": 1559,
-        "current_goal_text":
-          "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»)) X160^1",
+        "current_goal_text": "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»)) X160^1",
         "current_goal_predicate": "from_mixin",
         "failed_attempts": [],
         "successful_attempts": [
@@ -120782,8 +116949,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 12,
                       "column": 0,
                       "character": 414
@@ -120810,8 +116976,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 12,
                     "column": 0,
                     "character": 414
@@ -120826,8 +116991,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -120884,13 +117048,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -120982,13 +117144,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -121003,13 +117163,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -121024,13 +117182,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -121045,13 +117201,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -121123,13 +117277,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -121220,13 +117372,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -121260,13 +117410,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -121300,13 +117448,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -121321,13 +117467,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -121627,13 +117771,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -121652,8 +117794,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -121678,13 +117819,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -121699,8 +117838,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -121732,8 +117870,7 @@
       "Inference",
       {
         "current_goal_id": 1560,
-        "current_goal_text":
-          "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X161^1",
+        "current_goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X161^1",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -121742,8 +117879,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -121770,13 +117906,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»)) X162^1",
+                "goal_text": "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»)) X162^1",
                 "goal_id": 1561
               },
               {
-                "goal_text":
-                  "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X163^1",
+                "goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X163^1",
                 "goal_id": 1562
               }
             ],
@@ -121789,8 +117923,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -121809,8 +117942,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -121867,13 +117999,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -121965,13 +118095,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -121986,13 +118114,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -122007,13 +118133,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -122028,13 +118152,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -122106,13 +118228,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -122203,13 +118323,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -122243,13 +118361,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -122283,13 +118399,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -122304,13 +118418,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -122610,13 +118722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -122635,8 +118745,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -122661,13 +118770,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -122682,8 +118789,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -122715,8 +118821,7 @@
       "Inference",
       {
         "current_goal_id": 1561,
-        "current_goal_text":
-          "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»)) X162^1",
+        "current_goal_text": "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»)) X162^1",
         "current_goal_predicate": "from_mixin",
         "failed_attempts": [],
         "successful_attempts": [
@@ -122729,8 +118834,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 12,
                       "column": 0,
                       "character": 414
@@ -122757,8 +118861,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 12,
                     "column": 0,
                     "character": 414
@@ -122773,8 +118876,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -122793,8 +118895,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -122851,13 +118952,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -122949,13 +119048,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -122970,13 +119067,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -122991,13 +119086,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -123012,13 +119105,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -123090,13 +119181,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -123187,13 +119276,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -123227,13 +119314,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -123267,13 +119352,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -123288,13 +119371,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -123594,13 +119675,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -123619,8 +119698,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -123645,13 +119723,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -123666,8 +119742,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -123699,8 +119774,7 @@
       "Inference",
       {
         "current_goal_id": 1562,
-        "current_goal_text":
-          "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X163^1",
+        "current_goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_mixin X163^1",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -123709,8 +119783,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -123734,8 +119807,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)) X164^1",
+                "goal_text": "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)) X164^1",
                 "goal_id": 1563
               },
               {
@@ -123752,8 +119824,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -123772,8 +119843,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -123792,8 +119862,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -123850,13 +119919,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -123948,13 +120015,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -123969,13 +120034,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -123990,13 +120053,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -124011,13 +120072,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -124089,13 +120148,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -124186,13 +120243,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -124226,13 +120281,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -124266,13 +120319,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -124287,13 +120338,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -124593,13 +120642,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -124618,8 +120665,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -124644,13 +120690,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -124665,8 +120709,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -124698,8 +120741,7 @@
       "Inference",
       {
         "current_goal_id": 1563,
-        "current_goal_text":
-          "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)) X164^1",
+        "current_goal_text": "from_mixin\n (from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)) X164^1",
         "current_goal_predicate": "from_mixin",
         "failed_attempts": [],
         "successful_attempts": [
@@ -124712,8 +120754,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 12,
                       "column": 0,
                       "character": 414
@@ -124740,8 +120781,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 12,
                     "column": 0,
                     "character": 414
@@ -124756,8 +120796,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -124776,8 +120815,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -124796,8 +120834,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -124854,13 +120891,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -124952,13 +120987,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -124973,13 +121006,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -124994,13 +121025,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -125015,13 +121044,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -125093,13 +121120,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -125190,13 +121215,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -125230,13 +121253,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -125270,13 +121291,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -125291,13 +121310,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -125597,13 +121614,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -125622,8 +121637,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -125648,13 +121662,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -125669,8 +121681,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -125754,8 +121765,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -125774,8 +121784,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -125794,8 +121803,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -125852,13 +121860,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -125950,13 +121956,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -125971,13 +121975,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -125992,13 +121994,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -126013,13 +122013,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -126091,13 +122089,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -126188,13 +122184,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -126228,13 +122222,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -126268,13 +122260,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -126289,13 +122279,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -126595,13 +122583,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -126620,8 +122606,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -126646,13 +122631,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -126667,8 +122650,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -126706,8 +122688,7 @@
       "Inference",
       {
         "current_goal_id": 1558,
-        "current_goal_text":
-          "std.do!\n [std.map\n   [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_24»), \n    from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n     (const «Builders_18.HB_unnamed_factory_22»), \n    from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1, \n  std.map2 X159^1 \n   [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n   (factory-provides.one [] c0) (X154 c0)]",
+        "current_goal_text": "std.do!\n [std.map\n   [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_24»), \n    from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n     (const «Builders_18.HB_unnamed_factory_22»), \n    from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n     (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1, \n  std.map2 X159^1 \n   [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n   (factory-provides.one [] c0) (X154 c0)]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -126716,8 +122697,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -126742,14 +122722,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.map\n [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»), \n  from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1",
+                "goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»), \n  from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1",
                 "goal_id": 1565
               },
               { "goal_text": "!", "goal_id": 1566 },
               {
-                "goal_text":
-                  "std.do!\n [std.map2 X159^1 \n   [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n   (factory-provides.one [] c0) (X154 c0)]",
+                "goal_text": "std.do!\n [std.map2 X159^1 \n   [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n   (factory-provides.one [] c0) (X154 c0)]",
                 "goal_id": 1567
               }
             ],
@@ -126819,13 +122797,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -126917,13 +122893,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -126938,13 +122912,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -126959,13 +122931,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -126980,13 +122950,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -127058,13 +123026,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -127155,13 +123121,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -127195,13 +123159,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -127235,13 +123197,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -127256,13 +123216,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -127562,13 +123520,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -127587,8 +123543,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -127613,13 +123568,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -127634,8 +123587,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -127667,8 +123619,7 @@
       "Inference",
       {
         "current_goal_id": 1565,
-        "current_goal_text":
-          "std.map\n [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»), \n  from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1",
+        "current_goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»), \n  from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X159^1",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -127677,8 +123628,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -127705,13 +123655,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»)) X166^1",
+                "goal_text": "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»)) X166^1",
                 "goal_id": 1568
               },
               {
-                "goal_text":
-                  "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X167^1",
+                "goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X167^1",
                 "goal_id": 1569
               }
             ],
@@ -127724,8 +123672,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -127801,13 +123748,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -127899,13 +123844,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -127920,13 +123863,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -127941,13 +123882,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -127962,13 +123901,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -128040,13 +123977,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -128137,13 +124072,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -128177,13 +124110,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -128217,13 +124148,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -128238,13 +124167,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -128544,13 +124471,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -128569,8 +124494,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -128595,13 +124519,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -128616,8 +124538,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -128649,8 +124570,7 @@
       "Inference",
       {
         "current_goal_id": 1568,
-        "current_goal_text":
-          "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»)) X166^1",
+        "current_goal_text": "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «IsSelfA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_24»)) X166^1",
         "current_goal_predicate": "from_builder",
         "failed_attempts": [],
         "successful_attempts": [
@@ -128659,13 +124579,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(from_builder (from _ _ A0) (global A0)) :- .",
+                  "rule_text": "(from_builder (from _ _ A0) (global A0)) :- .",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 15,
                       "column": 0,
                       "character": 476
@@ -128698,8 +124616,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 15,
                     "column": 0,
                     "character": 476
@@ -128714,8 +124631,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -128791,13 +124707,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -128889,13 +124803,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -128910,13 +124822,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -128931,13 +124841,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -128952,13 +124860,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -129030,13 +124936,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -129127,13 +125031,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -129167,13 +125069,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -129207,13 +125107,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -129228,13 +125126,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -129534,13 +125430,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -129559,8 +125453,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -129585,13 +125478,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -129606,8 +125497,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -129639,8 +125529,7 @@
       "Inference",
       {
         "current_goal_id": 1569,
-        "current_goal_text":
-          "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X167^1",
+        "current_goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»), \n  from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X167^1",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -129649,8 +125538,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -129677,13 +125565,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»)) X168^1",
+                "goal_text": "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»)) X168^1",
                 "goal_id": 1570
               },
               {
-                "goal_text":
-                  "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X169^1",
+                "goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X169^1",
                 "goal_id": 1571
               }
             ],
@@ -129696,8 +125582,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -129716,8 +125601,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -129793,13 +125677,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -129891,13 +125773,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -129912,13 +125792,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -129933,13 +125811,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -129954,13 +125830,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -130032,13 +125906,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -130129,13 +126001,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -130169,13 +126039,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -130209,13 +126077,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -130230,13 +126096,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -130536,13 +126400,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -130561,8 +126423,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -130587,13 +126448,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -130608,8 +126467,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -130641,8 +126499,7 @@
       "Inference",
       {
         "current_goal_id": 1570,
-        "current_goal_text":
-          "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»)) X168^1",
+        "current_goal_text": "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «HasB.axioms_») \n   (const «Builders_18.HB_unnamed_factory_22»)) X168^1",
         "current_goal_predicate": "from_builder",
         "failed_attempts": [],
         "successful_attempts": [
@@ -130651,13 +126508,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(from_builder (from _ _ A0) (global A0)) :- .",
+                  "rule_text": "(from_builder (from _ _ A0) (global A0)) :- .",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 15,
                       "column": 0,
                       "character": 476
@@ -130690,8 +126545,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 15,
                     "column": 0,
                     "character": 476
@@ -130706,8 +126560,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -130726,8 +126579,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -130803,13 +126655,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -130901,13 +126751,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -130922,13 +126770,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -130943,13 +126789,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -130964,13 +126808,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -131042,13 +126884,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -131139,13 +126979,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -131179,13 +127017,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -131219,13 +127055,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -131240,13 +127074,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -131546,13 +127378,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -131571,8 +127401,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -131597,13 +127426,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -131618,8 +127445,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -131651,8 +127477,7 @@
       "Inference",
       {
         "current_goal_id": 1571,
-        "current_goal_text":
-          "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X169^1",
+        "current_goal_text": "std.map\n [from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)] from_builder X169^1",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -131661,8 +127486,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -131686,8 +127510,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)) X170^1",
+                "goal_text": "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)) X170^1",
                 "goal_id": 1572
               },
               {
@@ -131704,8 +127527,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -131724,8 +127546,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -131744,8 +127565,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -131821,13 +127641,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -131919,13 +127737,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -131940,13 +127756,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -131961,13 +127775,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -131982,13 +127794,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -132060,13 +127870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -132157,13 +127965,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -132197,13 +128003,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -132237,13 +128041,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -132258,13 +128060,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -132564,13 +128364,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -132589,8 +128387,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -132615,13 +128412,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -132636,8 +128431,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -132669,8 +128463,7 @@
       "Inference",
       {
         "current_goal_id": 1572,
-        "current_goal_text":
-          "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)) X170^1",
+        "current_goal_text": "from_builder\n (from (indt «IsSelfA'.axioms_») (indt «HasA.axioms_») \n   (const «Builders_18.HB_unnamed_factory_20»)) X170^1",
         "current_goal_predicate": "from_builder",
         "failed_attempts": [],
         "successful_attempts": [
@@ -132679,13 +128472,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(from_builder (from _ _ A0) (global A0)) :- .",
+                  "rule_text": "(from_builder (from _ _ A0) (global A0)) :- .",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 15,
                       "column": 0,
                       "character": 476
@@ -132718,8 +128509,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 15,
                     "column": 0,
                     "character": 476
@@ -132734,8 +128524,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -132754,8 +128543,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -132774,8 +128562,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -132851,13 +128638,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -132949,13 +128734,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -132970,13 +128753,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -132991,13 +128772,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -133012,13 +128791,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -133090,13 +128867,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -133187,13 +128962,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -133227,13 +129000,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -133267,13 +129038,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -133288,13 +129057,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -133594,13 +129361,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -133619,8 +129384,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -133645,13 +129409,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -133666,8 +129428,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -133751,8 +129512,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -133771,8 +129531,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -133791,8 +129550,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -133868,13 +129626,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -133966,13 +129722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -133987,13 +129741,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -134008,13 +129760,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -134029,13 +129779,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -134107,13 +129855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -134204,13 +129950,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -134244,13 +129988,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -134284,13 +130026,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -134305,13 +130045,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -134611,13 +130349,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -134636,8 +130372,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -134662,13 +130397,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -134683,8 +130416,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -134722,8 +130454,7 @@
       "Inference",
       {
         "current_goal_id": 1567,
-        "current_goal_text":
-          "std.do!\n [std.map2\n   [global (const «Builders_18.HB_unnamed_factory_24»), \n    global (const «Builders_18.HB_unnamed_factory_22»), \n    global (const «Builders_18.HB_unnamed_factory_20»)] \n   [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n   (factory-provides.one [] c0) (X154 c0)]",
+        "current_goal_text": "std.do!\n [std.map2\n   [global (const «Builders_18.HB_unnamed_factory_24»), \n    global (const «Builders_18.HB_unnamed_factory_22»), \n    global (const «Builders_18.HB_unnamed_factory_20»)] \n   [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n   (factory-provides.one [] c0) (X154 c0)]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -134732,8 +130463,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -134755,8 +130485,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.map2\n [global (const «Builders_18.HB_unnamed_factory_24»), \n  global (const «Builders_18.HB_unnamed_factory_22»), \n  global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n (factory-provides.one [] c0) (X154 c0)",
+                "goal_text": "std.map2\n [global (const «Builders_18.HB_unnamed_factory_24»), \n  global (const «Builders_18.HB_unnamed_factory_22»), \n  global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n (factory-provides.one [] c0) (X154 c0)",
                 "goal_id": 1574
               },
               { "goal_text": "!", "goal_id": 1575 },
@@ -134847,13 +130576,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -134945,13 +130672,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -134966,13 +130691,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -134987,13 +130710,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -135008,13 +130729,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -135086,13 +130805,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -135183,13 +130900,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -135223,13 +130938,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -135263,13 +130976,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -135284,13 +130995,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -135590,13 +131299,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -135615,8 +131322,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -135641,13 +131347,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -135662,8 +131366,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -135695,8 +131398,7 @@
       "Inference",
       {
         "current_goal_id": 1574,
-        "current_goal_text":
-          "std.map2\n [global (const «Builders_18.HB_unnamed_factory_24»), \n  global (const «Builders_18.HB_unnamed_factory_22»), \n  global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n (factory-provides.one [] c0) (X154 c0)",
+        "current_goal_text": "std.map2\n [global (const «Builders_18.HB_unnamed_factory_24»), \n  global (const «Builders_18.HB_unnamed_factory_22»), \n  global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «IsSelfA.axioms_», indt «HasB.axioms_», indt «HasA.axioms_»] \n (factory-provides.one [] c0) (X154 c0)",
         "current_goal_predicate": "std.map2",
         "failed_attempts": [],
         "successful_attempts": [
@@ -135705,8 +131407,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                  "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                   "rule_loc": [
                     "File",
                     {
@@ -135739,13 +131440,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "factory-provides.one [] c0 \n (global (const «Builders_18.HB_unnamed_factory_24»)) \n (indt «IsSelfA.axioms_») X173^1",
+                "goal_text": "factory-provides.one [] c0 \n (global (const «Builders_18.HB_unnamed_factory_24»)) \n (indt «IsSelfA.axioms_») X173^1",
                 "goal_id": 1577
               },
               {
-                "goal_text":
-                  "std.map2\n [global (const «Builders_18.HB_unnamed_factory_22»), \n  global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «HasB.axioms_», indt «HasA.axioms_»] (factory-provides.one [] c0) \n X174^1",
+                "goal_text": "std.map2\n [global (const «Builders_18.HB_unnamed_factory_22»), \n  global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «HasB.axioms_», indt «HasA.axioms_»] (factory-provides.one [] c0) \n X174^1",
                 "goal_id": 1578
               }
             ],
@@ -135758,8 +131457,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -135854,13 +131552,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -135952,13 +131648,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -135973,13 +131667,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -135994,13 +131686,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -136015,13 +131705,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -136093,13 +131781,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -136190,13 +131876,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -136230,13 +131914,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -136270,13 +131952,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -136291,13 +131971,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -136597,13 +132275,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -136622,8 +132298,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -136648,13 +132323,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -136669,8 +132342,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -136702,8 +132374,7 @@
       "Inference",
       {
         "current_goal_id": 1577,
-        "current_goal_text":
-          "factory-provides.one [] c0 \n (global (const «Builders_18.HB_unnamed_factory_24»)) \n (indt «IsSelfA.axioms_») X173^1",
+        "current_goal_text": "factory-provides.one [] c0 \n (global (const «Builders_18.HB_unnamed_factory_24»)) \n (indt «IsSelfA.axioms_») X173^1",
         "current_goal_predicate": "factory-provides.one",
         "failed_attempts": [],
         "successful_attempts": [
@@ -136712,13 +132383,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                  "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 108,
                       "column": 0,
                       "character": 3601
@@ -136742,8 +132411,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) \n     X176^1) Builder illtyped, \n  (coq.subst-prod [] X176^1 X177^1 , coq.subst-prod [c0] X177^1 X178^1), \n  std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+                "goal_text": "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) \n     X176^1) Builder illtyped, \n  (coq.subst-prod [] X176^1 X177^1 , coq.subst-prod [c0] X177^1 X178^1), \n  std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
                 "goal_id": 1579
               }
             ],
@@ -136756,13 +132424,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -136777,8 +132443,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -136873,13 +132538,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -136971,13 +132634,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -136992,13 +132653,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -137013,13 +132672,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -137034,13 +132691,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -137112,13 +132767,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -137209,13 +132862,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -137249,13 +132900,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -137289,13 +132938,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -137310,13 +132957,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -137616,13 +133261,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -137641,8 +133284,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -137667,13 +133309,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -137688,8 +133328,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -137721,8 +133360,7 @@
       "Inference",
       {
         "current_goal_id": 1579,
-        "current_goal_text":
-          "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) \n     X176^1) Builder illtyped, \n  (coq.subst-prod [] X176^1 X177^1 , coq.subst-prod [c0] X177^1 X178^1), \n  std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+        "current_goal_text": "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) \n     X176^1) Builder illtyped, \n  (coq.subst-prod [] X176^1 X177^1 , coq.subst-prod [c0] X177^1 X178^1), \n  std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -137731,8 +133369,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -137757,14 +133394,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1) \n Builder illtyped",
+                "goal_text": "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1) \n Builder illtyped",
                 "goal_id": 1580
               },
               { "goal_text": "!", "goal_id": 1581 },
               {
-                "goal_text":
-                  "std.do!\n [(coq.subst-prod [] X176^1 X177^1 , coq.subst-prod [c0] X177^1 X178^1), \n  std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+                "goal_text": "std.do!\n [(coq.subst-prod [] X176^1 X177^1 , coq.subst-prod [c0] X177^1 X178^1), \n  std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
                 "goal_id": 1582
               }
             ],
@@ -137796,13 +133431,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -137817,8 +133450,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -137913,13 +133545,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -138011,13 +133641,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -138032,13 +133660,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -138053,13 +133679,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -138074,13 +133698,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -138152,13 +133774,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -138249,13 +133869,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -138289,13 +133907,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -138329,13 +133945,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -138350,13 +133964,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -138656,13 +134268,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -138681,8 +134291,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -138707,13 +134316,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -138728,8 +134335,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -138761,8 +134367,7 @@
       "Inference",
       {
         "current_goal_id": 1580,
-        "current_goal_text":
-          "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1) \n Builder illtyped",
+        "current_goal_text": "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1) \n Builder illtyped",
         "current_goal_predicate": "std.assert-ok!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -138771,8 +134376,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                  "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -138794,14 +134398,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1 \n X179^1",
+                "goal_text": "coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1 \n X179^1",
                 "goal_id": 1583
               },
               { "goal_text": "!", "goal_id": 1584 },
               {
-                "goal_text":
-                  "X179^1 = ok ;\n X179^1 = error X180^1 , std.fatal-error-w-data Builder illtyped X180^1",
+                "goal_text": "X179^1 = ok ;\n X179^1 = error X180^1 , std.fatal-error-w-data Builder illtyped X180^1",
                 "goal_id": 1585
               },
               { "goal_text": "!", "goal_id": 1586 }
@@ -138815,8 +134417,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -138854,13 +134455,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -138875,8 +134474,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -138971,13 +134569,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -139069,13 +134665,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -139090,13 +134684,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -139111,13 +134703,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -139132,13 +134722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -139210,13 +134798,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -139307,13 +134893,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -139347,13 +134931,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -139387,13 +134969,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -139408,13 +134988,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -139714,13 +135292,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -139739,8 +135315,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -139765,13 +135340,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -139786,8 +135359,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -139819,8 +135391,7 @@
       "Inference",
       {
         "current_goal_id": 1583,
-        "current_goal_text":
-          "coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1 \n X179^1",
+        "current_goal_text": "coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1 \n X179^1",
         "current_goal_predicate": "coq.typecheck",
         "failed_attempts": [],
         "successful_attempts": [
@@ -139831,8 +135402,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X176^1 =\n prod `T` (sort (typ «interleave_context.396»)) c1 \\\n  prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n   c2 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c1, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]",
+                "goal_text": "X176^1 =\n prod `T` (sort (typ «interleave_context.396»)) c1 \\\n  prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n   c2 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c1, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]",
                 "goal_id": 1587
               },
               { "goal_text": "X179^1 = ok", "goal_id": 1588 }
@@ -139851,8 +135421,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -139890,13 +135459,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -139911,8 +135478,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -140007,13 +135573,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -140105,13 +135669,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -140126,13 +135688,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -140147,13 +135707,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -140168,13 +135726,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -140246,13 +135802,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -140343,13 +135897,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -140383,13 +135935,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -140423,13 +135973,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -140444,13 +135992,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -140750,13 +136296,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -140775,8 +136319,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -140801,13 +136344,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -140822,8 +136363,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -140855,8 +136395,7 @@
       "Inference",
       {
         "current_goal_id": 1587,
-        "current_goal_text":
-          "X176^1 =\n prod `T` (sort (typ «interleave_context.396»)) c1 \\\n  prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n   c2 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c1, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]",
+        "current_goal_text": "X176^1 =\n prod `T` (sort (typ «interleave_context.396»)) c1 \\\n  prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n   c2 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c1, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -140890,8 +136429,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -140929,13 +136467,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -140950,8 +136486,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -141046,13 +136581,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -141144,13 +136677,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -141165,13 +136696,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -141186,13 +136715,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -141207,13 +136734,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -141285,13 +136810,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -141382,13 +136905,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -141422,13 +136943,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -141462,13 +136981,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -141483,13 +137000,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -141789,13 +137304,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -141814,8 +137327,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -141840,13 +137352,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -141861,8 +137371,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -141923,8 +137432,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -141962,13 +137470,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -141983,8 +137489,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -142079,13 +137584,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -142177,13 +137680,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -142198,13 +137699,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -142219,13 +137718,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -142240,13 +137737,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -142318,13 +137813,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -142415,13 +137908,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -142455,13 +137946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -142495,13 +137984,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -142516,13 +138003,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -142822,13 +138307,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -142847,8 +138330,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -142873,13 +138355,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -142894,8 +138374,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -142930,13 +138409,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1) \n Builder illtyped",
+              "goal_text": "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_24»)) X176^1) \n Builder illtyped",
               "goal_id": 1580
             },
             "cut_branch": {
-              "rule_text":
-                "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
+              "rule_text": "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
               "rule_loc": [
                 "File",
                 {
@@ -142960,8 +138437,7 @@
       "Inference",
       {
         "current_goal_id": 1585,
-        "current_goal_text":
-          "ok = ok ; ok = error X180^1 , std.fatal-error-w-data Builder illtyped X180^1",
+        "current_goal_text": "ok = ok ; ok = error X180^1 , std.fatal-error-w-data Builder illtyped X180^1",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -143013,8 +138489,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -143052,13 +138527,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -143073,8 +138546,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -143169,13 +138641,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -143267,13 +138737,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -143288,13 +138756,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -143309,13 +138775,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -143330,13 +138794,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -143408,13 +138870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -143505,13 +138965,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -143545,13 +139003,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -143585,13 +139041,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -143606,13 +139060,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -143912,13 +139364,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -143937,8 +139387,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -143963,13 +139412,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -143984,8 +139431,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -144060,8 +139506,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -144099,13 +139544,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -144120,8 +139563,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -144216,13 +139658,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -144314,13 +139754,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -144335,13 +139773,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -144356,13 +139792,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -144377,13 +139811,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -144455,13 +139887,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -144552,13 +139982,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -144592,13 +140020,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -144632,13 +140058,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -144653,13 +140077,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -144959,13 +140381,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -144984,8 +140404,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -145010,13 +140429,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -145031,8 +140448,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -145067,8 +140483,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "X179^1 = ok ;\n X179^1 = error X180^1 , std.fatal-error-w-data Builder illtyped X180^1",
+              "goal_text": "X179^1 = ok ;\n X179^1 = error X180^1 , std.fatal-error-w-data Builder illtyped X180^1",
               "goal_id": 1585
             },
             "cut_branch": {
@@ -145102,8 +140517,7 @@
       "Inference",
       {
         "current_goal_id": 1582,
-        "current_goal_text":
-          "std.do!\n [(coq.subst-prod [] \n    (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n      prod `fresh_name_19` \n       (app [global (const «IsSelfA'.phant_axioms»), c1]) c2 \\\n       app\n        [global (indt «IsSelfA.axioms_»), c1, \n         app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n         app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n    X177^1 , coq.subst-prod [c0] X177^1 X178^1), \n  std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+        "current_goal_text": "std.do!\n [(coq.subst-prod [] \n    (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n      prod `fresh_name_19` \n       (app [global (const «IsSelfA'.phant_axioms»), c1]) c2 \\\n       app\n        [global (indt «IsSelfA.axioms_»), c1, \n         app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n         app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n    X177^1 , coq.subst-prod [c0] X177^1 X178^1), \n  std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -145112,8 +140526,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -145138,14 +140551,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1 , coq.subst-prod [c0] X177^1 X178^1",
+                "goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1 , coq.subst-prod [c0] X177^1 X178^1",
                 "goal_id": 1590
               },
               { "goal_text": "!", "goal_id": 1591 },
               {
-                "goal_text":
-                  "std.do!\n [std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+                "goal_text": "std.do!\n [std.assert! (extract-conclusion-params c0 X178^1 X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
                 "goal_id": 1592
               }
             ],
@@ -145196,13 +140607,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -145217,8 +140626,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -145313,13 +140721,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -145411,13 +140817,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -145432,13 +140836,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -145453,13 +140855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -145474,13 +140874,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -145552,13 +140950,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -145649,13 +141045,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -145689,13 +141083,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -145729,13 +141121,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -145750,13 +141140,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -146056,13 +141444,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -146081,8 +141467,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -146107,13 +141492,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -146128,8 +141511,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -146161,8 +141543,7 @@
       "Inference",
       {
         "current_goal_id": 1590,
-        "current_goal_text":
-          "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1 , coq.subst-prod [c0] X177^1 X178^1",
+        "current_goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1 , coq.subst-prod [c0] X177^1 X178^1",
         "current_goal_predicate": ",",
         "failed_attempts": [],
         "successful_attempts": [
@@ -146173,8 +141554,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1",
+                "goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1",
                 "goal_id": 1593
               },
               {
@@ -146234,13 +141614,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -146255,8 +141633,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -146351,13 +141728,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -146449,13 +141824,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -146470,13 +141843,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -146491,13 +141862,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -146512,13 +141881,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -146590,13 +141957,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -146687,13 +142052,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -146727,13 +142090,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -146767,13 +142128,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -146788,13 +142147,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -147094,13 +142451,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -147119,8 +142474,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -147145,13 +142499,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -147166,8 +142518,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -147199,8 +142550,7 @@
       "Inference",
       {
         "current_goal_id": 1593,
-        "current_goal_text":
-          "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1",
+        "current_goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1",
         "current_goal_predicate": "coq.subst-prod",
         "failed_attempts": [],
         "successful_attempts": [
@@ -147304,13 +142654,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -147325,8 +142673,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -147421,13 +142768,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -147519,13 +142864,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -147540,13 +142883,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -147561,13 +142902,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -147582,13 +142921,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -147660,13 +142997,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -147757,13 +143092,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -147797,13 +143130,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -147837,13 +143168,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -147858,13 +143187,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -148164,13 +143491,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -148189,8 +143514,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -148215,13 +143539,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -148236,8 +143558,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -148272,13 +143593,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1",
+              "goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X177^1",
               "goal_id": 1593
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
+              "rule_text": "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
               "rule_loc": [
                 "File",
                 {
@@ -148302,8 +143621,7 @@
       "Inference",
       {
         "current_goal_id": 1594,
-        "current_goal_text":
-          "coq.subst-prod [c0] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X178^1",
+        "current_goal_text": "coq.subst-prod [c0] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «IsSelfA.axioms_»), c1, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c1, c2], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c1, c2]]) \n X178^1",
         "current_goal_predicate": "coq.subst-prod",
         "failed_attempts": [],
         "successful_attempts": [
@@ -148312,8 +143630,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
+                  "rule_text": "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
                   "rule_loc": [
                     "File",
                     {
@@ -148338,8 +143655,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1596 },
               {
-                "goal_text":
-                  "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X178^1",
+                "goal_text": "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X178^1",
                 "goal_id": 1597
               }
             ],
@@ -148352,8 +143668,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
+                "rule_text": "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -148415,13 +143730,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -148436,8 +143749,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -148532,13 +143844,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -148630,13 +143940,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -148651,13 +143959,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -148672,13 +143978,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -148693,13 +143997,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -148771,13 +144073,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -148868,13 +144168,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -148908,13 +144206,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -148948,13 +144244,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -148969,13 +144263,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -149275,13 +144567,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -149300,8 +144590,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -149326,13 +144615,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -149347,8 +144634,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -149387,8 +144673,7 @@
               "goal_id": 1594
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
+              "rule_text": "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
               "rule_loc": [
                 "File",
                 {
@@ -149406,8 +144691,7 @@
               "goal_id": 1594
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.subst-prod [_ | _] A0 _) :- (!), \n (std.fatal-error-w-data subst-prod: not a product A0).",
+              "rule_text": "(coq.subst-prod [_ | _] A0 _) :- (!), \n (std.fatal-error-w-data subst-prod: not a product A0).",
               "rule_loc": [
                 "File",
                 {
@@ -149431,8 +144715,7 @@
       "Inference",
       {
         "current_goal_id": 1597,
-        "current_goal_text":
-          "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X178^1",
+        "current_goal_text": "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X178^1",
         "current_goal_predicate": "coq.subst-prod",
         "failed_attempts": [],
         "successful_attempts": [
@@ -149493,8 +144776,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
+                "rule_text": "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -149556,13 +144838,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -149577,8 +144857,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -149673,13 +144952,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -149771,13 +145048,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -149792,13 +145067,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -149813,13 +145086,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -149834,13 +145105,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -149912,13 +145181,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -150009,13 +145276,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -150049,13 +145314,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -150089,13 +145352,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -150110,13 +145371,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -150416,13 +145675,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -150441,8 +145698,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -150467,13 +145723,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -150488,8 +145742,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -150524,13 +145777,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X178^1",
+              "goal_text": "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X178^1",
               "goal_id": 1597
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
+              "rule_text": "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
               "rule_loc": [
                 "File",
                 {
@@ -150560,8 +145811,7 @@
       "Inference",
       {
         "current_goal_id": 1592,
-        "current_goal_text":
-          "std.do!\n [std.assert!\n   (extract-conclusion-params c0 \n     (prod `fresh_name_19` \n       (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n       app\n        [global (indt «IsSelfA.axioms_»), c0, \n         app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n         app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n     X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+        "current_goal_text": "std.do!\n [std.assert!\n   (extract-conclusion-params c0 \n     (prod `fresh_name_19` \n       (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n       app\n        [global (indt «IsSelfA.axioms_»), c0, \n         app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n         app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n     X175^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -150570,8 +145820,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -150593,8 +145842,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.assert!\n (extract-conclusion-params c0 \n   (prod `fresh_name_19` \n     (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n     app\n      [global (indt «IsSelfA.axioms_»), c0, \n       app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n       app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n   X175^1) \n The conclusion of a builder is a mixin whose parameters depend on other mixins",
+                "goal_text": "std.assert!\n (extract-conclusion-params c0 \n   (prod `fresh_name_19` \n     (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n     app\n      [global (indt «IsSelfA.axioms_»), c0, \n       app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n       app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n   X175^1) \n The conclusion of a builder is a mixin whose parameters depend on other mixins",
                 "goal_id": 1599
               },
               { "goal_text": "!", "goal_id": 1600 },
@@ -150666,13 +145914,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -150687,8 +145933,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -150783,13 +146028,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -150881,13 +146124,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -150902,13 +146143,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -150923,13 +146162,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -150944,13 +146181,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -151022,13 +146257,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -151119,13 +146352,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -151159,13 +146390,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -151199,13 +146428,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -151220,13 +146447,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -151526,13 +146751,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -151551,8 +146774,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -151577,13 +146799,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -151598,8 +146818,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -151631,8 +146850,7 @@
       "Inference",
       {
         "current_goal_id": 1599,
-        "current_goal_text":
-          "std.assert!\n (extract-conclusion-params c0 \n   (prod `fresh_name_19` \n     (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n     app\n      [global (indt «IsSelfA.axioms_»), c0, \n       app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n       app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n   X175^1) \n The conclusion of a builder is a mixin whose parameters depend on other mixins",
+        "current_goal_text": "std.assert!\n (extract-conclusion-params c0 \n   (prod `fresh_name_19` \n     (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n     app\n      [global (indt «IsSelfA.axioms_»), c0, \n       app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n       app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n   X175^1) \n The conclusion of a builder is a mixin whose parameters depend on other mixins",
         "current_goal_predicate": "std.assert!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -151641,8 +146859,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                  "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -151667,8 +146884,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «IsSelfA.axioms_»), c0, \n        app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n        app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n    X175^1)",
+                "goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «IsSelfA.axioms_»), c0, \n        app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n        app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n    X175^1)",
                 "goal_id": 1602
               },
               { "goal_text": "!", "goal_id": 1603 }
@@ -151682,8 +146898,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -151759,13 +146974,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -151780,8 +146993,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -151876,13 +147088,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -151974,13 +147184,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -151995,13 +147203,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -152016,13 +147222,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -152037,13 +147241,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -152115,13 +147317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -152212,13 +147412,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -152252,13 +147450,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -152292,13 +147488,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -152313,13 +147507,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -152619,13 +147811,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -152644,8 +147834,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -152670,13 +147859,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -152691,8 +147878,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -152724,8 +147910,7 @@
       "Inference",
       {
         "current_goal_id": 1602,
-        "current_goal_text":
-          "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «IsSelfA.axioms_»), c0, \n        app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n        app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n    X175^1)",
+        "current_goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «IsSelfA.axioms_»), c0, \n        app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n        app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n    X175^1)",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -152755,8 +147940,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
+                "goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
                 "goal_id": 1604
               }
             ],
@@ -152788,8 +147972,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -152865,13 +148048,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -152886,8 +148067,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -152982,13 +148162,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -153080,13 +148258,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -153101,13 +148277,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -153122,13 +148296,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -153143,13 +148315,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -153221,13 +148391,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -153318,13 +148486,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -153358,13 +148524,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -153398,13 +148562,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -153419,13 +148581,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -153725,13 +148885,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -153750,8 +148908,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -153776,13 +148933,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -153797,8 +148952,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -153830,8 +148984,7 @@
       "Inference",
       {
         "current_goal_id": 1604,
-        "current_goal_text":
-          "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
+        "current_goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
         "current_goal_predicate": "extract-conclusion-params",
         "failed_attempts": [],
         "successful_attempts": [
@@ -153840,13 +148993,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                  "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 115,
                       "column": 0,
                       "character": 3974
@@ -153870,8 +149021,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1605 },
               {
-                "goal_text":
-                  "pi c1 \\\n decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n  extract-conclusion-params c0 \n   (app\n     [global (indt «IsSelfA.axioms_»), c0, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n   X175^1",
+                "goal_text": "pi c1 \\\n decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n  extract-conclusion-params c0 \n   (app\n     [global (indt «IsSelfA.axioms_»), c0, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n   X175^1",
                 "goal_id": 1606
               }
             ],
@@ -153884,13 +149034,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -153924,8 +149072,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -154001,13 +149148,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -154022,8 +149167,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -154118,13 +149262,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -154216,13 +149358,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -154237,13 +149377,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -154258,13 +149396,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -154279,13 +149415,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -154357,13 +149491,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -154454,13 +149586,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -154494,13 +149624,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -154534,13 +149662,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -154555,13 +149681,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -154861,13 +149985,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -154886,8 +150008,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -154912,13 +150033,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -154933,8 +150052,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -154969,18 +150087,15 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
+              "goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
               "goal_id": 1604
             },
             "cut_branch": {
-              "rule_text":
-                "(extract-conclusion-params A0 (app [global A1 | A2]) A3) :- (!), \n (factory-alias->gref A1 A4), (factory-nparams A4 A5), \n (std.map A2 (copy-pack-holes A0) A6), (std.spy (std.take A5 A6 A3)).",
+              "rule_text": "(extract-conclusion-params A0 (app [global A1 | A2]) A3) :- (!), \n (factory-alias->gref A1 A4), (factory-nparams A4 A5), \n (std.map A2 (copy-pack-holes A0) A6), (std.spy (std.take A5 A6 A3)).",
               "rule_loc": [
                 "File",
                 {
-                  "filename":
-                    "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                  "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                   "line": 117,
                   "column": 0,
                   "character": 4090
@@ -154990,18 +150105,15 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
+              "goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
               "goal_id": 1604
             },
             "cut_branch": {
-              "rule_text":
-                "(extract-conclusion-params A0 A1 A2) :- (whd1 A1 A3), (!), \n (extract-conclusion-params A0 A3 A2).",
+              "rule_text": "(extract-conclusion-params A0 A1 A2) :- (whd1 A1 A3), (!), \n (extract-conclusion-params A0 A3 A2).",
               "rule_loc": [
                 "File",
                 {
-                  "filename":
-                    "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                  "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                   "line": 122,
                   "column": 0,
                   "character": 4303
@@ -155021,8 +150133,7 @@
       "Inference",
       {
         "current_goal_id": 1606,
-        "current_goal_text":
-          "pi c1 \\\n decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n  extract-conclusion-params c0 \n   (app\n     [global (indt «IsSelfA.axioms_»), c0, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n   X175^1",
+        "current_goal_text": "pi c1 \\\n decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n  extract-conclusion-params c0 \n   (app\n     [global (indt «IsSelfA.axioms_»), c0, \n      app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n      app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n   X175^1",
         "current_goal_predicate": "pi",
         "failed_attempts": [],
         "successful_attempts": [
@@ -155033,8 +150144,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n extract-conclusion-params c0 \n  (app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n  X175^1",
+                "goal_text": "decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n extract-conclusion-params c0 \n  (app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n  X175^1",
                 "goal_id": 1607
               }
             ],
@@ -155052,13 +150162,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -155092,8 +150200,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -155169,13 +150276,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -155190,8 +150295,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -155286,13 +150390,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -155384,13 +150486,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -155405,13 +150505,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -155426,13 +150524,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -155447,13 +150543,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -155525,13 +150619,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -155622,13 +150714,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -155662,13 +150752,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -155702,13 +150790,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -155723,13 +150809,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -156029,13 +151113,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -156054,8 +151136,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -156080,13 +151161,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -156101,8 +151180,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -156134,8 +151212,7 @@
       "Inference",
       {
         "current_goal_id": 1607,
-        "current_goal_text":
-          "decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n extract-conclusion-params c0 \n  (app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n  X175^1",
+        "current_goal_text": "decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n extract-conclusion-params c0 \n  (app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n  X175^1",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -156146,8 +151223,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "extract-conclusion-params c0 \n (app\n   [global (indt «IsSelfA.axioms_»), c0, \n    app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
+                "goal_text": "extract-conclusion-params c0 \n (app\n   [global (indt «IsSelfA.axioms_»), c0, \n    app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
                 "goal_id": 1608
               }
             ],
@@ -156170,13 +151246,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -156210,8 +151284,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -156287,13 +151360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -156308,8 +151379,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -156404,13 +151474,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -156502,13 +151570,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -156523,13 +151589,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -156544,13 +151608,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -156565,13 +151627,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -156643,13 +151703,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -156740,13 +151798,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -156780,13 +151836,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -156820,13 +151874,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -156841,13 +151893,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -157147,13 +152197,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -157172,8 +152220,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -157198,13 +152245,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -157219,8 +152264,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -157252,21 +152296,18 @@
       "Inference",
       {
         "current_goal_id": 1608,
-        "current_goal_text":
-          "extract-conclusion-params c0 \n (app\n   [global (indt «IsSelfA.axioms_»), c0, \n    app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
+        "current_goal_text": "extract-conclusion-params c0 \n (app\n   [global (indt «IsSelfA.axioms_»), c0, \n    app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
         "current_goal_predicate": "extract-conclusion-params",
         "failed_attempts": [
           {
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (app [global A1 | A2]) A3) :- (!), \n (factory-alias->gref A1 A4), (factory-nparams A4 A5), \n (std.map A2 (copy-pack-holes A0) A6), (std.spy (std.take A5 A6 A3)).",
+                "rule_text": "(extract-conclusion-params A0 (app [global A1 | A2]) A3) :- (!), \n (factory-alias->gref A1 A4), (factory-nparams A4 A5), \n (std.map A2 (copy-pack-holes A0) A6), (std.spy (std.take A5 A6 A3)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 117,
                     "column": 0,
                     "character": 4090
@@ -157291,13 +152332,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                  "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 115,
                       "column": 0,
                       "character": 3974
@@ -157316,8 +152355,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1609 },
               {
-                "goal_text":
-                  "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
+                "goal_text": "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
                 "goal_id": 1610
               },
               {
@@ -157325,8 +152363,7 @@
                 "goal_id": 1611
               },
               {
-                "goal_text":
-                  "std.map\n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X183^2",
+                "goal_text": "std.map\n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X183^2",
                 "goal_id": 1612
               },
               {
@@ -157343,13 +152380,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -157374,13 +152409,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -157414,8 +152447,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -157491,13 +152523,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -157512,8 +152542,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -157608,13 +152637,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -157706,13 +152733,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -157727,13 +152752,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -157748,13 +152771,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -157769,13 +152790,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -157847,13 +152866,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -157944,13 +152961,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -157984,13 +152999,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -158024,13 +153037,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -158045,13 +153056,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -158351,13 +153360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -158376,8 +153383,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -158402,13 +153408,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -158423,8 +153427,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -158459,18 +153462,15 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "extract-conclusion-params c0 \n (app\n   [global (indt «IsSelfA.axioms_»), c0, \n    app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
+              "goal_text": "extract-conclusion-params c0 \n (app\n   [global (indt «IsSelfA.axioms_»), c0, \n    app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1",
               "goal_id": 1608
             },
             "cut_branch": {
-              "rule_text":
-                "(extract-conclusion-params A0 A1 A2) :- (whd1 A1 A3), (!), \n (extract-conclusion-params A0 A3 A2).",
+              "rule_text": "(extract-conclusion-params A0 A1 A2) :- (whd1 A1 A3), (!), \n (extract-conclusion-params A0 A3 A2).",
               "rule_loc": [
                 "File",
                 {
-                  "filename":
-                    "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                  "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                   "line": 122,
                   "column": 0,
                   "character": 4303
@@ -158490,8 +153490,7 @@
       "Inference",
       {
         "current_goal_id": 1610,
-        "current_goal_text":
-          "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
+        "current_goal_text": "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
         "current_goal_predicate": "factory-alias->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -158500,13 +153499,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                  "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 74,
                       "column": 0,
                       "character": 2385
@@ -158521,8 +153518,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "phant-abbrev X181^2 (indt «IsSelfA.axioms_») _",
+                "goal_text": "phant-abbrev X181^2 (indt «IsSelfA.axioms_») _",
                 "goal_id": 1614
               },
               { "goal_text": "!", "goal_id": 1615 }
@@ -158536,13 +153532,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 74,
                     "column": 0,
                     "character": 2385
@@ -158557,13 +153551,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -158588,13 +153580,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -158628,8 +153618,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -158705,13 +153694,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -158726,8 +153713,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -158822,13 +153808,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -158920,13 +153904,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -158941,13 +153923,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -158962,13 +153942,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -158983,13 +153961,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -159061,13 +154037,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -159158,13 +154132,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -159198,13 +154170,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -159238,13 +154208,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -159259,13 +154227,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -159565,13 +154531,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -159590,8 +154554,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -159616,13 +154579,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -159637,8 +154598,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -159670,16 +154630,14 @@
       "Inference",
       {
         "current_goal_id": 1614,
-        "current_goal_text":
-          "phant-abbrev X181^2 (indt «IsSelfA.axioms_») _",
+        "current_goal_text": "phant-abbrev X181^2 (indt «IsSelfA.axioms_») _",
         "current_goal_predicate": "phant-abbrev",
         "failed_attempts": [
           {
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -159703,8 +154661,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -159728,8 +154685,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -159753,8 +154709,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -159778,8 +154733,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -159803,8 +154757,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -159828,8 +154781,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -159853,8 +154805,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -159882,8 +154833,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -159902,13 +154852,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 74,
                     "column": 0,
                     "character": 2385
@@ -159923,13 +154871,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -159954,13 +154900,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -159994,8 +154938,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -160071,13 +155014,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -160092,8 +155033,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -160188,13 +155128,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -160286,13 +155224,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -160307,13 +155243,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -160328,13 +155262,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -160349,13 +155281,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -160427,13 +155357,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -160524,13 +155452,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -160564,13 +155490,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -160604,13 +155528,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -160625,13 +155547,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -160931,13 +155851,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -160956,8 +155874,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -160982,13 +155899,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -161003,8 +155918,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -161036,8 +155950,7 @@
       "Inference",
       {
         "current_goal_id": 1610,
-        "current_goal_text":
-          "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
+        "current_goal_text": "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
         "current_goal_predicate": "factory-alias->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -161046,13 +155959,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                  "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 75,
                       "column": 0,
                       "character": 2443
@@ -161081,13 +155992,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2443
@@ -161102,13 +156011,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -161133,13 +156040,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -161173,8 +156078,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -161250,13 +156154,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -161271,8 +156173,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -161367,13 +156268,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -161465,13 +156364,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -161486,13 +156383,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -161507,13 +156402,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -161528,13 +156421,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -161606,13 +156497,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -161703,13 +156592,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -161743,13 +156630,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -161783,13 +156668,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -161804,13 +156687,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -162110,13 +156991,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -162135,8 +157014,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -162161,13 +157039,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -162182,8 +157058,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -162222,8 +157097,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -162246,8 +157120,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -162268,8 +157141,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                  "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                   "rule_loc": [
                     "File",
                     {
@@ -162298,8 +157170,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -162318,13 +157189,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2443
@@ -162339,13 +157208,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -162370,13 +157237,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -162410,8 +157275,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -162487,13 +157351,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -162508,8 +157370,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -162604,13 +157465,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -162702,13 +157561,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -162723,13 +157580,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -162744,13 +157599,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -162765,13 +157618,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -162843,13 +157694,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -162940,13 +157789,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -162980,13 +157827,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -163020,13 +157865,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -163041,13 +157884,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -163347,13 +158188,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -163372,8 +158211,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -163398,13 +158236,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -163419,8 +158255,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -163459,8 +158294,7 @@
               "goal_id": 1616
             },
             "cut_branch": {
-              "rule_text":
-                "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
+              "rule_text": "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
               "rule_loc": [
                 "File",
                 {
@@ -163474,13 +158308,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
+              "goal_text": "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
               "goal_id": 1610
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «A.axioms_») (indt «A.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «A.axioms_») (indt «A.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -163494,13 +158326,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
+              "goal_text": "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
               "goal_id": 1610
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «B.axioms_») (indt «B.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «B.axioms_») (indt «B.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -163514,13 +158344,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
+              "goal_text": "factory-alias->gref (indt «IsSelfA.axioms_») X181^2",
               "goal_id": 1610
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «SelfA.axioms_») (indt «SelfA.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «SelfA.axioms_») (indt «SelfA.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -163544,8 +158372,7 @@
       "Inference",
       {
         "current_goal_id": 1611,
-        "current_goal_text":
-          "factory-nparams (indt «IsSelfA.axioms_») X182^2",
+        "current_goal_text": "factory-nparams (indt «IsSelfA.axioms_») X182^2",
         "current_goal_predicate": "factory-nparams",
         "failed_attempts": [
           {
@@ -163575,8 +158402,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «HasB.axioms_») 1) :- .",
+                "rule_text": "(factory-nparams (indt «HasB.axioms_») 1) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -163622,8 +158448,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «IsSelfA.axioms_») 0) :- .",
+                "rule_text": "(factory-nparams (indt «IsSelfA.axioms_») 0) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -163644,8 +158469,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-nparams (indt «HasA.axioms_») 1) :- .",
+                  "rule_text": "(factory-nparams (indt «HasA.axioms_») 1) :- .",
                   "rule_loc": [
                     "File",
                     {
@@ -163674,8 +158498,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «HasA.axioms_») 1) :- .",
+                "rule_text": "(factory-nparams (indt «HasA.axioms_») 1) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -163694,13 +158517,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -163725,13 +158546,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -163765,8 +158584,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -163842,13 +158660,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -163863,8 +158679,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -163959,13 +158774,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -164057,13 +158870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -164078,13 +158889,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -164099,13 +158908,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -164120,13 +158927,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -164198,13 +159003,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -164295,13 +159098,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -164335,13 +159136,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -164375,13 +159174,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -164396,13 +159193,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -164702,13 +159497,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -164727,8 +159520,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -164753,13 +159545,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -164774,8 +159564,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -164807,8 +159596,7 @@
       "Inference",
       {
         "current_goal_id": 1612,
-        "current_goal_text":
-          "std.map\n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X183^2",
+        "current_goal_text": "std.map\n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X183^2",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -164817,8 +159605,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -164846,8 +159633,7 @@
                 "goal_id": 1618
               },
               {
-                "goal_text":
-                  "std.map\n [app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X185^2",
+                "goal_text": "std.map\n [app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X185^2",
                 "goal_id": 1619
               }
             ],
@@ -164860,8 +159646,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -164880,13 +159665,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -164911,13 +159694,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -164951,8 +159732,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -165028,13 +159808,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -165049,8 +159827,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -165145,13 +159922,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -165243,13 +160018,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -165264,13 +160037,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -165285,13 +160056,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -165306,13 +160075,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -165384,13 +160151,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -165481,13 +160246,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -165521,13 +160284,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -165561,13 +160322,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -165582,13 +160341,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -165888,13 +160645,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -165913,8 +160668,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -165939,13 +160693,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -165960,8 +160712,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -166002,13 +160753,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                  "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 318,
                       "column": 0,
                       "character": 12866
@@ -166032,8 +160781,7 @@
                 "goal_id": 1621
               },
               {
-                "goal_text":
-                  "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X188^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X188^2 | c6] c3) | X187^2]\n => copy c0 X184^2",
+                "goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X188^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X188^2 | c6] c3) | X187^2]\n => copy c0 X184^2",
                 "goal_id": 1622
               }
             ],
@@ -166046,13 +160794,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -166067,8 +160813,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -166087,13 +160832,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -166118,13 +160861,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -166158,8 +160899,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -166235,13 +160975,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -166256,8 +160994,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -166352,13 +161089,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -166450,13 +161185,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -166471,13 +161204,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -166492,13 +161223,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -166513,13 +161242,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -166591,13 +161318,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -166688,13 +161413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -166728,13 +161451,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -166768,13 +161489,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -166789,13 +161508,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -167095,13 +161812,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -167120,8 +161835,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -167146,13 +161860,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -167167,8 +161879,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -167209,13 +161920,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                  "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 200,
                       "column": 0,
                       "character": 7260
@@ -167244,13 +161953,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -167265,13 +161972,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -167286,8 +161991,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -167306,13 +162010,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -167337,13 +162039,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -167377,8 +162077,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -167454,13 +162153,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -167475,8 +162172,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -167571,13 +162267,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -167669,13 +162363,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -167690,13 +162382,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -167711,13 +162401,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -167732,13 +162420,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -167810,13 +162496,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -167907,13 +162591,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -167947,13 +162629,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -167987,13 +162667,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -168008,13 +162686,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -168314,13 +162990,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -168339,8 +163013,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -168365,13 +163038,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -168386,8 +163057,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -168428,8 +163098,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                  "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -168448,8 +163117,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "findall_solutions (local-canonical X189^2) X190^2",
+                "goal_text": "findall_solutions (local-canonical X189^2) X190^2",
                 "goal_id": 1625
               }
             ],
@@ -168462,8 +163130,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -168482,13 +163149,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -168503,13 +163168,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -168524,8 +163187,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -168544,13 +163206,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -168575,13 +163235,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -168615,8 +163273,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -168692,13 +163349,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -168713,8 +163368,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -168809,13 +163463,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -168907,13 +163559,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -168928,13 +163578,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -168949,13 +163597,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -168970,13 +163616,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -169048,13 +163692,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -169145,13 +163787,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -169185,13 +163825,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -169225,13 +163863,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -169246,13 +163882,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -169552,13 +164186,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -169577,8 +164209,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -169603,13 +164234,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -169624,8 +164253,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -169657,8 +164285,7 @@
       "Findall",
       {
         "findall_goal_id": 1625,
-        "findall_goal_text":
-          "findall_solutions (local-canonical X189^2) X190^2",
+        "findall_goal_text": "findall_solutions (local-canonical X189^2) X190^2",
         "findall_cards": [
           {
             "step_id": 0,
@@ -169698,8 +164325,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -169718,13 +164344,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -169739,13 +164363,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -169760,8 +164382,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -169780,13 +164401,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -169811,13 +164430,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -169851,8 +164468,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -169928,13 +164544,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -169949,8 +164563,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -170045,13 +164658,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -170143,13 +164754,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -170164,13 +164773,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -170185,13 +164792,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -170206,13 +164811,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -170284,13 +164887,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -170381,13 +164982,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -170421,13 +165020,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -170461,13 +165058,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -170482,13 +165077,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -170788,13 +165381,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -170813,8 +165404,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -170839,13 +165429,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -170860,8 +165448,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -170945,13 +165532,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -170966,13 +165551,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -170987,8 +165570,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -171007,13 +165589,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -171038,13 +165618,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -171078,8 +165656,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -171155,13 +165732,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -171176,8 +165751,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -171272,13 +165846,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -171370,13 +165942,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -171391,13 +165961,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -171412,13 +165980,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -171433,13 +165999,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -171511,13 +166075,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -171608,13 +166170,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -171648,13 +166208,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -171688,13 +166246,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -171709,13 +166265,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -172015,13 +166569,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -172040,8 +166592,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -172066,13 +166617,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -172087,8 +166636,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -172133,8 +166681,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                       "line": 196,
                       "column": 0,
                       "character": 7411
@@ -172158,8 +166705,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 7411
@@ -172174,13 +166720,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -172195,8 +166739,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -172215,13 +166758,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -172246,13 +166787,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -172286,8 +166825,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -172363,13 +166901,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -172384,8 +166920,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -172480,13 +167015,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -172578,13 +167111,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -172599,13 +167130,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -172620,13 +167149,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -172641,13 +167168,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -172719,13 +167244,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -172816,13 +167339,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -172856,13 +167377,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -172896,13 +167415,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -172917,13 +167434,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -173223,13 +167738,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -173248,8 +167761,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -173274,13 +167786,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -173295,8 +167805,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -173328,8 +167837,7 @@
       "Inference",
       {
         "current_goal_id": 1622,
-        "current_goal_text":
-          "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X188^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X188^2 | c6] c3)] =>\n copy c0 X184^2",
+        "current_goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X188^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X188^2 | c6] c3)] =>\n copy c0 X184^2",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -173355,13 +167863,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -173376,8 +167882,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -173396,13 +167901,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -173427,13 +167930,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -173467,8 +167968,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -173544,13 +168044,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -173565,8 +168063,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -173661,13 +168158,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -173759,13 +168254,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -173780,13 +168273,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -173801,13 +168292,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -173822,13 +168311,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -173900,13 +168387,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -173997,13 +168482,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -174037,13 +168520,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -174077,13 +168558,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -174098,13 +168577,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -174404,13 +168881,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -174429,8 +168904,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -174455,13 +168929,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -174476,8 +168948,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -174518,8 +168989,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -174532,8 +169002,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := c0" ],
-                [ "Assign", "A1 := X184^2" ]
+                [ "Assign", "A0 := c0" ], [ "Assign", "A1 := X184^2" ]
               ]
             },
             "siblings": [
@@ -174551,8 +169020,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -174576,13 +169044,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -174597,8 +169063,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -174617,13 +169082,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -174648,13 +169111,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -174688,8 +169149,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -174765,13 +169225,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -174786,8 +169244,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -174882,13 +169339,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -174980,13 +169435,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -175001,13 +169454,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -175022,13 +169473,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -175043,13 +169492,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -175121,13 +169568,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -175218,13 +169663,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -175258,13 +169701,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -175298,13 +169739,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -175319,13 +169758,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -175625,13 +170062,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -175650,8 +170085,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -175676,13 +170110,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -175697,8 +170129,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -175754,8 +170185,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -175779,13 +170209,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -175800,8 +170228,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -175820,13 +170247,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -175851,13 +170276,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -175891,8 +170314,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -175968,13 +170390,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -175989,8 +170409,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -176085,13 +170504,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -176183,13 +170600,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -176204,13 +170619,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -176225,13 +170638,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -176246,13 +170657,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -176324,13 +170733,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -176421,13 +170828,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -176461,13 +170866,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -176501,13 +170904,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -176522,13 +170923,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -176828,13 +171227,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -176853,8 +171250,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -176879,13 +171275,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -176900,8 +171294,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -176962,8 +171355,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -176987,13 +171379,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -177008,8 +171398,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -177028,13 +171417,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -177059,13 +171446,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -177099,8 +171484,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -177176,13 +171560,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -177197,8 +171579,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -177293,13 +171674,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -177391,13 +171770,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -177412,13 +171789,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -177433,13 +171808,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -177454,13 +171827,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -177532,13 +171903,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -177629,13 +171998,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -177669,13 +172036,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -177709,13 +172074,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -177730,13 +172093,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -178036,13 +172397,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -178061,8 +172420,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -178087,13 +172445,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -178108,8 +172464,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -178171,8 +172526,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -178196,13 +172550,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -178217,8 +172569,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -178237,13 +172588,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -178268,13 +172617,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -178308,8 +172655,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -178385,13 +172731,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -178406,8 +172750,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -178502,13 +172845,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -178600,13 +172941,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -178621,13 +172960,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -178642,13 +172979,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -178663,13 +172998,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -178741,13 +173074,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -178838,13 +173169,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -178878,13 +173207,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -178918,13 +173245,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -178939,13 +173264,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -179245,13 +173568,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -179270,8 +173591,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -179296,13 +173616,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -179317,8 +173635,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -179356,8 +173673,7 @@
       "Inference",
       {
         "current_goal_id": 1619,
-        "current_goal_text":
-          "std.map\n [app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X185^2",
+        "current_goal_text": "std.map\n [app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X185^2",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -179366,8 +173682,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -179394,13 +173709,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "copy-pack-holes c0 \n (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) X191^2",
+                "goal_text": "copy-pack-holes c0 \n (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) X191^2",
                 "goal_id": 1634
               },
               {
-                "goal_text":
-                  "std.map [app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X192^2",
+                "goal_text": "std.map [app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X192^2",
                 "goal_id": 1635
               }
             ],
@@ -179413,8 +173726,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -179433,8 +173745,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -179453,13 +173764,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -179484,13 +173793,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -179524,8 +173831,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -179601,13 +173907,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -179622,8 +173926,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -179718,13 +174021,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -179816,13 +174117,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -179837,13 +174136,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -179858,13 +174155,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -179879,13 +174174,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -179957,13 +174250,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -180054,13 +174345,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -180094,13 +174383,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -180134,13 +174421,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -180155,13 +174440,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -180461,13 +174744,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -180486,8 +174767,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -180512,13 +174792,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -180533,8 +174811,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -180566,8 +174843,7 @@
       "Inference",
       {
         "current_goal_id": 1634,
-        "current_goal_text":
-          "copy-pack-holes c0 \n (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) X191^2",
+        "current_goal_text": "copy-pack-holes c0 \n (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) X191^2",
         "current_goal_predicate": "copy-pack-holes",
         "failed_attempts": [],
         "successful_attempts": [
@@ -180576,13 +174852,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                  "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 318,
                       "column": 0,
                       "character": 12866
@@ -180609,8 +174883,7 @@
                 "goal_id": 1637
               },
               {
-                "goal_text":
-                  "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X195^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X195^2 | c6] c3) | X194^2]\n =>\n copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n  X191^2",
+                "goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X195^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X195^2 | c6] c3) | X194^2]\n =>\n copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n  X191^2",
                 "goal_id": 1638
               }
             ],
@@ -180623,13 +174896,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -180644,8 +174915,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -180664,8 +174934,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -180684,13 +174953,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -180715,13 +174982,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -180755,8 +175020,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -180832,13 +175096,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -180853,8 +175115,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -180949,13 +175210,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -181047,13 +175306,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -181068,13 +175325,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -181089,13 +175344,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -181110,13 +175363,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -181188,13 +175439,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -181285,13 +175534,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -181325,13 +175572,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -181365,13 +175610,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -181386,13 +175629,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -181692,13 +175933,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -181717,8 +175956,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -181743,13 +175981,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -181764,8 +176000,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -181806,13 +176041,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                  "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 200,
                       "column": 0,
                       "character": 7260
@@ -181841,13 +176074,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -181862,13 +176093,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -181883,8 +176112,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -181903,8 +176131,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -181923,13 +176150,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -181954,13 +176179,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -181994,8 +176217,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -182071,13 +176293,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -182092,8 +176312,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -182188,13 +176407,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -182286,13 +176503,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -182307,13 +176522,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -182328,13 +176541,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -182349,13 +176560,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -182427,13 +176636,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -182524,13 +176731,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -182564,13 +176769,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -182604,13 +176807,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -182625,13 +176826,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -182931,13 +177130,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -182956,8 +177153,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -182982,13 +177178,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -183003,8 +177197,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -183045,8 +177238,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                  "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -183065,8 +177257,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "findall_solutions (local-canonical X196^2) X197^2",
+                "goal_text": "findall_solutions (local-canonical X196^2) X197^2",
                 "goal_id": 1641
               }
             ],
@@ -183079,8 +177270,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -183099,13 +177289,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -183120,13 +177308,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -183141,8 +177327,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -183161,8 +177346,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -183181,13 +177365,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -183212,13 +177394,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -183252,8 +177432,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -183329,13 +177508,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -183350,8 +177527,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -183446,13 +177622,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -183544,13 +177718,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -183565,13 +177737,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -183586,13 +177756,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -183607,13 +177775,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -183685,13 +177851,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -183782,13 +177946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -183822,13 +177984,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -183862,13 +178022,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -183883,13 +178041,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -184189,13 +178345,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -184214,8 +178368,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -184240,13 +178393,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -184261,8 +178412,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -184294,8 +178444,7 @@
       "Findall",
       {
         "findall_goal_id": 1641,
-        "findall_goal_text":
-          "findall_solutions (local-canonical X196^2) X197^2",
+        "findall_goal_text": "findall_solutions (local-canonical X196^2) X197^2",
         "findall_cards": [
           {
             "step_id": 0,
@@ -184335,8 +178484,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -184355,13 +178503,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -184376,13 +178522,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -184397,8 +178541,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -184417,8 +178560,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -184437,13 +178579,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -184468,13 +178608,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -184508,8 +178646,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -184585,13 +178722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -184606,8 +178741,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -184702,13 +178836,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -184800,13 +178932,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -184821,13 +178951,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -184842,13 +178970,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -184863,13 +178989,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -184941,13 +179065,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -185038,13 +179160,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -185078,13 +179198,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -185118,13 +179236,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -185139,13 +179255,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -185445,13 +179559,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -185470,8 +179582,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -185496,13 +179607,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -185517,8 +179626,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -185602,13 +179710,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -185623,13 +179729,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -185644,8 +179748,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -185664,8 +179767,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -185684,13 +179786,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -185715,13 +179815,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -185755,8 +179853,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -185832,13 +179929,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -185853,8 +179948,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -185949,13 +180043,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -186047,13 +180139,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -186068,13 +180158,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -186089,13 +180177,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -186110,13 +180196,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -186188,13 +180272,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -186285,13 +180367,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -186325,13 +180405,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -186365,13 +180443,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -186386,13 +180462,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -186692,13 +180766,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -186717,8 +180789,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -186743,13 +180814,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -186764,8 +180833,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -186810,8 +180878,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                       "line": 196,
                       "column": 0,
                       "character": 7411
@@ -186835,8 +180902,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 7411
@@ -186851,13 +180917,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -186872,8 +180936,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -186892,8 +180955,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -186912,13 +180974,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -186943,13 +181003,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -186983,8 +181041,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -187060,13 +181117,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -187081,8 +181136,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -187177,13 +181231,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -187275,13 +181327,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -187296,13 +181346,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -187317,13 +181365,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -187338,13 +181384,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -187416,13 +181460,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -187513,13 +181555,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -187553,13 +181593,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -187593,13 +181631,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -187614,13 +181650,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -187920,13 +181954,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -187945,8 +181977,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -187971,13 +182002,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -187992,8 +182021,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -188025,8 +182053,7 @@
       "Inference",
       {
         "current_goal_id": 1638,
-        "current_goal_text":
-          "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X195^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X195^2 | c6] c3)] =>\n copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n  X191^2",
+        "current_goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X195^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X195^2 | c6] c3)] =>\n copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n  X191^2",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -188037,8 +182064,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n X191^2",
+                "goal_text": "copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n X191^2",
                 "goal_id": 1644
               }
             ],
@@ -188056,13 +182082,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -188077,8 +182101,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -188097,8 +182120,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -188117,13 +182139,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -188148,13 +182168,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -188188,8 +182206,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -188265,13 +182282,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -188286,8 +182301,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -188382,13 +182396,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -188480,13 +182492,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -188501,13 +182511,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -188522,13 +182530,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -188543,13 +182549,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -188621,13 +182625,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -188718,13 +182720,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -188758,13 +182758,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -188798,13 +182796,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -188819,13 +182815,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -189125,13 +183119,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -189150,8 +183142,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -189176,13 +183167,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -189197,8 +183186,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -189230,8 +183218,7 @@
       "Inference",
       {
         "current_goal_id": 1644,
-        "current_goal_text":
-          "copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n X191^2",
+        "current_goal_text": "copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n X191^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -189240,8 +183227,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X195^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X195^2 | A4] A1).",
+                  "rule_text": "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X195^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X195^2 | A4] A1).",
                   "rule_loc": [ "Context", 451 ]
                 }
               ],
@@ -189259,8 +183245,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "pack? (const «Builders_18.HB_unnamed_factory_20») _",
+                "goal_text": "pack? (const «Builders_18.HB_unnamed_factory_20») _",
                 "goal_id": 1645
               },
               { "goal_text": "!", "goal_id": 1646 },
@@ -189271,8 +183256,7 @@
               { "goal_text": "copy c0 X195^2", "goal_id": 1648 },
               { "goal_text": "std.map X200^2 copy X201^2", "goal_id": 1649 },
               {
-                "goal_text":
-                  "std.rev [global (const «elpi.hole»), X195^2 | X201^2] X198^2",
+                "goal_text": "std.rev [global (const «elpi.hole»), X195^2 | X201^2] X198^2",
                 "goal_id": 1650
               }
             ],
@@ -189285,8 +183269,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X195^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X195^2 | A4] A1).",
+                "rule_text": "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X195^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X195^2 | A4] A1).",
                 "rule_loc": [ "Context", 451 ]
               }
             ],
@@ -189302,13 +183285,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -189323,8 +183304,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -189343,8 +183323,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -189363,13 +183342,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -189394,13 +183371,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -189434,8 +183409,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -189511,13 +183485,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -189532,8 +183504,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -189628,13 +183599,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -189726,13 +183695,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -189747,13 +183714,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -189768,13 +183733,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -189789,13 +183752,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -189867,13 +183828,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -189964,13 +183923,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -190004,13 +183961,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -190044,13 +183999,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -190065,13 +184018,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -190371,13 +184322,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -190396,8 +184345,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -190422,13 +184370,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -190443,8 +184389,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -190476,8 +184421,7 @@
       "Inference",
       {
         "current_goal_id": 1645,
-        "current_goal_text":
-          "pack? (const «Builders_18.HB_unnamed_factory_20») _",
+        "current_goal_text": "pack? (const «Builders_18.HB_unnamed_factory_20») _",
         "current_goal_predicate": "pack?",
         "failed_attempts": [],
         "successful_attempts": [],
@@ -190487,8 +184431,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X195^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X195^2 | A4] A1).",
+                "rule_text": "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X195^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X195^2 | A4] A1).",
                 "rule_loc": [ "Context", 451 ]
               }
             ],
@@ -190504,13 +184447,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -190525,8 +184466,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -190545,8 +184485,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -190565,13 +184504,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -190596,13 +184533,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -190636,8 +184571,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -190713,13 +184647,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -190734,8 +184666,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -190830,13 +184761,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -190928,13 +184857,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -190949,13 +184876,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -190970,13 +184895,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -190991,13 +184914,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -191069,13 +184990,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -191166,13 +185085,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -191206,13 +185123,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -191246,13 +185161,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -191267,13 +185180,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -191573,13 +185484,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -191598,8 +185507,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -191624,13 +185532,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -191645,8 +185551,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -191678,8 +185583,7 @@
       "Inference",
       {
         "current_goal_id": 1644,
-        "current_goal_text":
-          "copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n X191^2",
+        "current_goal_text": "copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n X191^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -191688,8 +185592,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -191711,14 +185614,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "name (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1])",
+                "goal_text": "name (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1])",
                 "goal_id": 1651
               },
               { "goal_text": "!", "goal_id": 1652 },
               {
-                "goal_text":
-                  "app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1] = X191^2",
+                "goal_text": "app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1] = X191^2",
                 "goal_id": 1653
               },
               { "goal_text": "!", "goal_id": 1654 }
@@ -191732,8 +185633,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -191757,13 +185657,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -191778,8 +185676,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -191798,8 +185695,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -191818,13 +185714,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -191849,13 +185743,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -191889,8 +185781,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -191966,13 +185857,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -191987,8 +185876,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -192083,13 +185971,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -192181,13 +186067,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -192202,13 +186086,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -192223,13 +186105,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -192244,13 +186124,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -192322,13 +186200,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -192419,13 +186295,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -192459,13 +186333,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -192499,13 +186371,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -192520,13 +186390,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -192826,13 +186694,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -192851,8 +186717,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -192877,13 +186742,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -192898,8 +186761,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -192931,8 +186793,7 @@
       "Inference",
       {
         "current_goal_id": 1651,
-        "current_goal_text":
-          "name (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1])",
+        "current_goal_text": "name (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1])",
         "current_goal_predicate": "name",
         "failed_attempts": [
           { "rule": [ "BuiltinRule", [ "FFI", "name" ] ], "events": [] }
@@ -192949,8 +186810,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -192974,13 +186834,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -192995,8 +186853,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -193015,8 +186872,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -193035,13 +186891,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -193066,13 +186920,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -193106,8 +186958,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -193183,13 +187034,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -193204,8 +187053,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -193300,13 +187148,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -193398,13 +187244,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -193419,13 +187263,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -193440,13 +187282,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -193461,13 +187301,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -193539,13 +187377,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -193636,13 +187472,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -193676,13 +187510,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -193716,13 +187548,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -193737,13 +187567,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -194043,13 +187871,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -194068,8 +187894,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -194094,13 +187919,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -194115,8 +187938,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -194148,8 +187970,7 @@
       "Inference",
       {
         "current_goal_id": 1644,
-        "current_goal_text":
-          "copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n X191^2",
+        "current_goal_text": "copy (app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1]) \n X191^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -194158,8 +187979,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                  "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -194182,8 +188002,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1655 },
               {
-                "goal_text":
-                  "std.map [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1] copy \n X202^2",
+                "goal_text": "std.map [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1] copy \n X202^2",
                 "goal_id": 1656
               }
             ],
@@ -194196,8 +188015,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -194221,13 +188039,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -194242,8 +188058,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -194262,8 +188077,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -194282,13 +188096,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -194313,13 +188125,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -194353,8 +188163,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -194430,13 +188239,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -194451,8 +188258,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -194547,13 +188353,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -194645,13 +188449,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -194666,13 +188468,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -194687,13 +188487,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -194708,13 +188506,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -194786,13 +188582,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -194883,13 +188677,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -194923,13 +188715,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -194963,13 +188753,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -194984,13 +188772,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -195290,13 +189076,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -195315,8 +189099,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -195341,13 +189124,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -195362,8 +189143,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -195401,8 +189181,7 @@
       "Inference",
       {
         "current_goal_id": 1656,
-        "current_goal_text":
-          "std.map [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1] copy \n X202^2",
+        "current_goal_text": "std.map [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1] copy \n X202^2",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -195411,8 +189190,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -195436,8 +189214,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "copy (global (const «Builders_18.HB_unnamed_factory_20»)) X203^2",
+                "goal_text": "copy (global (const «Builders_18.HB_unnamed_factory_20»)) X203^2",
                 "goal_id": 1657
               },
               {
@@ -195454,8 +189231,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -195474,8 +189250,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -195499,13 +189274,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -195520,8 +189293,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -195540,8 +189312,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -195560,13 +189331,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -195591,13 +189360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -195631,8 +189398,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -195708,13 +189474,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -195729,8 +189493,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -195825,13 +189588,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -195923,13 +189684,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -195944,13 +189703,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -195965,13 +189722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -195986,13 +189741,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -196064,13 +189817,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -196161,13 +189912,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -196201,13 +189950,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -196241,13 +189988,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -196262,13 +190007,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -196568,13 +190311,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -196593,8 +190334,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -196619,13 +190359,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -196640,8 +190378,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -196673,8 +190410,7 @@
       "Inference",
       {
         "current_goal_id": 1657,
-        "current_goal_text":
-          "copy (global (const «Builders_18.HB_unnamed_factory_20»)) X203^2",
+        "current_goal_text": "copy (global (const «Builders_18.HB_unnamed_factory_20»)) X203^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -196683,8 +190419,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -196706,14 +190441,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "name (global (const «Builders_18.HB_unnamed_factory_20»))",
+                "goal_text": "name (global (const «Builders_18.HB_unnamed_factory_20»))",
                 "goal_id": 1659
               },
               { "goal_text": "!", "goal_id": 1660 },
               {
-                "goal_text":
-                  "global (const «Builders_18.HB_unnamed_factory_20») = X203^2",
+                "goal_text": "global (const «Builders_18.HB_unnamed_factory_20») = X203^2",
                 "goal_id": 1661
               },
               { "goal_text": "!", "goal_id": 1662 }
@@ -196727,8 +190460,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -196747,8 +190479,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -196767,8 +190498,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -196792,13 +190522,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -196813,8 +190541,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -196833,8 +190560,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -196853,13 +190579,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -196884,13 +190608,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -196924,8 +190646,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -197001,13 +190722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -197022,8 +190741,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -197118,13 +190836,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -197216,13 +190932,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -197237,13 +190951,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -197258,13 +190970,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -197279,13 +190989,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -197357,13 +191065,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -197454,13 +191160,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -197494,13 +191198,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -197534,13 +191236,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -197555,13 +191255,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -197861,13 +191559,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -197886,8 +191582,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -197912,13 +191607,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -197933,8 +191626,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -197966,8 +191658,7 @@
       "Inference",
       {
         "current_goal_id": 1659,
-        "current_goal_text":
-          "name (global (const «Builders_18.HB_unnamed_factory_20»))",
+        "current_goal_text": "name (global (const «Builders_18.HB_unnamed_factory_20»))",
         "current_goal_predicate": "name",
         "failed_attempts": [
           { "rule": [ "BuiltinRule", [ "FFI", "name" ] ], "events": [] }
@@ -197984,8 +191675,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -198004,8 +191694,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -198024,8 +191713,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -198049,13 +191737,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -198070,8 +191756,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -198090,8 +191775,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -198110,13 +191794,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -198141,13 +191823,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -198181,8 +191861,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -198258,13 +191937,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -198279,8 +191956,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -198375,13 +192051,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -198473,13 +192147,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -198494,13 +192166,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -198515,13 +192185,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -198536,13 +192204,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -198614,13 +192280,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -198711,13 +192375,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -198751,13 +192413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -198791,13 +192451,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -198812,13 +192470,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -199118,13 +192774,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -199143,8 +192797,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -199169,13 +192822,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -199190,8 +192841,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -199223,8 +192873,7 @@
       "Inference",
       {
         "current_goal_id": 1657,
-        "current_goal_text":
-          "copy (global (const «Builders_18.HB_unnamed_factory_20»)) X203^2",
+        "current_goal_text": "copy (global (const «Builders_18.HB_unnamed_factory_20»)) X203^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -199285,8 +192934,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -199305,8 +192953,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -199330,13 +192977,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -199351,8 +192996,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -199371,8 +193015,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -199391,13 +193034,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -199422,13 +193063,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -199462,8 +193101,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -199539,13 +193177,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -199560,8 +193196,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -199656,13 +193291,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -199754,13 +193387,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -199775,13 +193406,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -199796,13 +193425,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -199817,13 +193444,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -199895,13 +193520,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -199992,13 +193615,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -200032,13 +193653,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -200072,13 +193691,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -200093,13 +193710,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -200399,13 +194014,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -200424,8 +194037,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -200450,13 +194062,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -200471,8 +194081,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -200519,8 +194128,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -200552,8 +194160,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -200572,8 +194179,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -200592,8 +194198,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -200617,13 +194222,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -200638,8 +194241,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -200658,8 +194260,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -200678,13 +194279,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -200709,13 +194308,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -200749,8 +194346,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -200826,13 +194422,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -200847,8 +194441,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -200943,13 +194536,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -201041,13 +194632,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -201062,13 +194651,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -201083,13 +194670,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -201104,13 +194689,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -201182,13 +194765,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -201279,13 +194860,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -201319,13 +194898,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -201359,13 +194936,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -201380,13 +194955,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -201686,13 +195259,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -201711,8 +195282,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -201737,13 +195307,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -201758,8 +195326,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -201800,8 +195367,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -201814,8 +195380,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := c0" ],
-                [ "Assign", "A1 := X205^2" ]
+                [ "Assign", "A0 := c0" ], [ "Assign", "A1 := X205^2" ]
               ]
             },
             "siblings": [
@@ -201833,8 +195398,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -201853,8 +195417,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -201873,8 +195436,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -201893,8 +195455,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -201918,13 +195479,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -201939,8 +195498,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -201959,8 +195517,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -201979,13 +195536,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -202010,13 +195565,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -202050,8 +195603,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -202127,13 +195679,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -202148,8 +195698,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -202244,13 +195793,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -202342,13 +195889,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -202363,13 +195908,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -202384,13 +195927,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -202405,13 +195946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -202483,13 +196022,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -202580,13 +196117,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -202620,13 +196155,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -202660,13 +196193,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -202681,13 +196212,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -202987,13 +196516,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -203012,8 +196539,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -203038,13 +196564,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -203059,8 +196583,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -203116,8 +196639,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -203136,8 +196658,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -203156,8 +196677,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -203176,8 +196696,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -203201,13 +196720,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -203222,8 +196739,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -203242,8 +196758,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -203262,13 +196777,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -203293,13 +196806,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -203333,8 +196844,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -203410,13 +196920,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -203431,8 +196939,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -203527,13 +197034,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -203625,13 +197130,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -203646,13 +197149,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -203667,13 +197168,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -203688,13 +197187,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -203766,13 +197263,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -203863,13 +197358,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -203903,13 +197396,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -203943,13 +197434,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -203964,13 +197453,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -204270,13 +197757,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -204295,8 +197780,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -204321,13 +197805,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -204342,8 +197824,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -204404,8 +197885,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -204424,8 +197904,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -204444,8 +197923,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -204464,8 +197942,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -204489,13 +197966,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -204510,8 +197985,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -204530,8 +198004,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -204550,13 +198023,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -204581,13 +198052,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -204621,8 +198090,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -204698,13 +198166,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -204719,8 +198185,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -204815,13 +198280,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -204913,13 +198376,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -204934,13 +198395,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -204955,13 +198414,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -204976,13 +198433,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -205054,13 +198509,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -205151,13 +198604,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -205191,13 +198642,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -205231,13 +198680,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -205252,13 +198699,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -205558,13 +199003,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -205583,8 +199026,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -205609,13 +199051,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -205630,8 +199070,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -205693,8 +199132,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -205713,8 +199151,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -205733,8 +199170,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -205753,8 +199189,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -205778,13 +199213,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -205799,8 +199232,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -205819,8 +199251,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -205839,13 +199270,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -205870,13 +199299,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -205910,8 +199337,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -205987,13 +199413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -206008,8 +199432,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -206104,13 +199527,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -206202,13 +199623,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -206223,13 +199642,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -206244,13 +199661,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -206265,13 +199680,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -206343,13 +199756,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -206440,13 +199851,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -206480,13 +199889,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -206520,13 +199927,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -206541,13 +199946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -206847,13 +200250,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -206872,8 +200273,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -206898,13 +200298,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -206919,8 +200317,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -206967,8 +200364,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -207000,8 +200396,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -207020,8 +200415,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -207040,8 +200434,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -207060,8 +200453,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -207085,13 +200477,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -207106,8 +200496,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -207126,8 +200515,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -207146,13 +200534,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -207177,13 +200563,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -207217,8 +200601,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -207294,13 +200677,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -207315,8 +200696,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -207411,13 +200791,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -207509,13 +200887,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -207530,13 +200906,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -207551,13 +200925,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -207572,13 +200944,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -207650,13 +201020,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -207747,13 +201115,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -207787,13 +201153,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -207827,13 +201191,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -207848,13 +201210,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -208154,13 +201514,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -208179,8 +201537,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -208205,13 +201562,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -208226,8 +201581,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -208268,8 +201622,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -208282,8 +201635,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := c1" ],
-                [ "Assign", "A1 := X207^2" ]
+                [ "Assign", "A0 := c1" ], [ "Assign", "A1 := X207^2" ]
               ]
             },
             "siblings": [
@@ -208301,8 +201653,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -208321,8 +201672,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -208341,8 +201691,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -208361,8 +201710,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -208381,8 +201729,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -208406,13 +201753,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -208427,8 +201772,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -208447,8 +201791,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -208467,13 +201810,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -208498,13 +201839,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -208538,8 +201877,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -208615,13 +201953,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -208636,8 +201972,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -208732,13 +202067,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -208830,13 +202163,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -208851,13 +202182,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -208872,13 +202201,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -208893,13 +202220,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -208971,13 +202296,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -209068,13 +202391,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -209108,13 +202429,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -209148,13 +202467,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -209169,13 +202486,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -209475,13 +202790,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -209500,8 +202813,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -209526,13 +202838,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -209547,8 +202857,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -209604,8 +202913,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -209624,8 +202932,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -209644,8 +202951,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -209664,8 +202970,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -209684,8 +202989,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -209709,13 +203013,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -209730,8 +203032,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -209750,8 +203051,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -209770,13 +203070,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -209801,13 +203099,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -209841,8 +203137,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -209918,13 +203213,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -209939,8 +203232,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -210035,13 +203327,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -210133,13 +203423,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -210154,13 +203442,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -210175,13 +203461,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -210196,13 +203480,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -210274,13 +203556,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -210371,13 +203651,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -210411,13 +203689,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -210451,13 +203727,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -210472,13 +203746,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -210778,13 +204050,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -210803,8 +204073,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -210829,13 +204098,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -210850,8 +204117,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -210912,8 +204178,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -210932,8 +204197,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -210952,8 +204216,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -210972,8 +204235,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -210992,8 +204254,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -211017,13 +204278,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -211038,8 +204297,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -211058,8 +204316,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -211078,13 +204335,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -211109,13 +204364,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -211149,8 +204402,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -211226,13 +204478,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -211247,8 +204497,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -211343,13 +204592,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -211441,13 +204688,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -211462,13 +204707,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -211483,13 +204726,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -211504,13 +204745,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -211582,13 +204821,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -211679,13 +204916,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -211719,13 +204954,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -211759,13 +204992,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -211780,13 +205011,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -212086,13 +205315,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -212111,8 +205338,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -212137,13 +205363,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -212158,8 +205382,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -212221,8 +205444,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -212241,8 +205463,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -212261,8 +205482,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -212281,8 +205501,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -212301,8 +205520,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -212326,13 +205544,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -212347,8 +205563,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -212367,8 +205582,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -212387,13 +205601,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -212418,13 +205630,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -212458,8 +205668,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -212535,13 +205744,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -212556,8 +205763,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -212652,13 +205858,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -212750,13 +205954,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -212771,13 +205973,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -212792,13 +205992,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -212813,13 +206011,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -212891,13 +206087,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -212988,13 +206182,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -213028,13 +206220,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -213068,13 +206258,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -213089,13 +206277,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -213395,13 +206581,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -213420,8 +206604,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -213446,13 +206629,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -213467,8 +206648,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -213558,8 +206738,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -213578,8 +206757,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -213598,8 +206776,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -213618,8 +206795,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -213643,13 +206819,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -213664,8 +206838,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -213684,8 +206857,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -213704,13 +206876,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -213735,13 +206905,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -213775,8 +206943,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -213852,13 +207019,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -213873,8 +207038,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -213969,13 +207133,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -214067,13 +207229,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -214088,13 +207248,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -214109,13 +207267,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -214130,13 +207286,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -214208,13 +207362,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -214305,13 +207457,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -214345,13 +207495,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -214385,13 +207533,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -214406,13 +207552,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -214712,13 +207856,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -214737,8 +207879,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -214763,13 +207904,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -214784,8 +207923,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -214817,8 +207955,7 @@
       "Inference",
       {
         "current_goal_id": 1635,
-        "current_goal_text":
-          "std.map [app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X192^2",
+        "current_goal_text": "std.map [app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n (copy-pack-holes c0) X192^2",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -214827,8 +207964,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -214852,8 +207988,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "copy-pack-holes c0 \n (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) X209^2",
+                "goal_text": "copy-pack-holes c0 \n (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) X209^2",
                 "goal_id": 1678
               },
               {
@@ -214870,8 +208005,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -214890,8 +208024,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -214910,8 +208043,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -214930,13 +208062,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -214961,13 +208091,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -215001,8 +208129,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -215078,13 +208205,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -215099,8 +208224,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -215195,13 +208319,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -215293,13 +208415,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -215314,13 +208434,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -215335,13 +208453,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -215356,13 +208472,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -215434,13 +208548,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -215531,13 +208643,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -215571,13 +208681,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -215611,13 +208719,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -215632,13 +208738,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -215938,13 +209042,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -215963,8 +209065,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -215989,13 +209090,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -216010,8 +209109,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -216043,8 +209141,7 @@
       "Inference",
       {
         "current_goal_id": 1678,
-        "current_goal_text":
-          "copy-pack-holes c0 \n (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) X209^2",
+        "current_goal_text": "copy-pack-holes c0 \n (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) X209^2",
         "current_goal_predicate": "copy-pack-holes",
         "failed_attempts": [],
         "successful_attempts": [
@@ -216053,13 +209150,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                  "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 318,
                       "column": 0,
                       "character": 12866
@@ -216086,8 +209181,7 @@
                 "goal_id": 1681
               },
               {
-                "goal_text":
-                  "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X213^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X213^2 | c6] c3) | X212^2]\n =>\n copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n  X209^2",
+                "goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X213^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X213^2 | c6] c3) | X212^2]\n =>\n copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n  X209^2",
                 "goal_id": 1682
               }
             ],
@@ -216100,13 +209194,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -216121,8 +209213,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -216141,8 +209232,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -216161,8 +209251,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -216181,13 +209270,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -216212,13 +209299,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -216252,8 +209337,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -216329,13 +209413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -216350,8 +209432,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -216446,13 +209527,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -216544,13 +209623,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -216565,13 +209642,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -216586,13 +209661,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -216607,13 +209680,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -216685,13 +209756,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -216782,13 +209851,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -216822,13 +209889,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -216862,13 +209927,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -216883,13 +209946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -217189,13 +210250,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -217214,8 +210273,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -217240,13 +210298,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -217261,8 +210317,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -217303,13 +210358,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                  "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 200,
                       "column": 0,
                       "character": 7260
@@ -217338,13 +210391,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -217359,13 +210410,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -217380,8 +210429,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -217400,8 +210448,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -217420,8 +210467,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -217440,13 +210486,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -217471,13 +210515,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -217511,8 +210553,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -217588,13 +210629,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -217609,8 +210648,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -217705,13 +210743,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -217803,13 +210839,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -217824,13 +210858,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -217845,13 +210877,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -217866,13 +210896,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -217944,13 +210972,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -218041,13 +211067,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -218081,13 +211105,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -218121,13 +211143,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -218142,13 +211162,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -218448,13 +211466,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -218473,8 +211489,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -218499,13 +211514,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -218520,8 +211533,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -218562,8 +211574,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                  "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -218582,8 +211593,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "findall_solutions (local-canonical X214^2) X215^2",
+                "goal_text": "findall_solutions (local-canonical X214^2) X215^2",
                 "goal_id": 1685
               }
             ],
@@ -218596,8 +211606,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -218616,13 +211625,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -218637,13 +211644,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -218658,8 +211663,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -218678,8 +211682,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -218698,8 +211701,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -218718,13 +211720,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -218749,13 +211749,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -218789,8 +211787,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -218866,13 +211863,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -218887,8 +211882,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -218983,13 +211977,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -219081,13 +212073,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -219102,13 +212092,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -219123,13 +212111,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -219144,13 +212130,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -219222,13 +212206,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -219319,13 +212301,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -219359,13 +212339,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -219399,13 +212377,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -219420,13 +212396,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -219726,13 +212700,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -219751,8 +212723,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -219777,13 +212748,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -219798,8 +212767,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -219831,8 +212799,7 @@
       "Findall",
       {
         "findall_goal_id": 1685,
-        "findall_goal_text":
-          "findall_solutions (local-canonical X214^2) X215^2",
+        "findall_goal_text": "findall_solutions (local-canonical X214^2) X215^2",
         "findall_cards": [
           {
             "step_id": 0,
@@ -219872,8 +212839,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -219892,13 +212858,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -219913,13 +212877,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -219934,8 +212896,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -219954,8 +212915,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -219974,8 +212934,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -219994,13 +212953,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -220025,13 +212982,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -220065,8 +213020,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -220142,13 +213096,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -220163,8 +213115,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -220259,13 +213210,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -220357,13 +213306,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -220378,13 +213325,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -220399,13 +213344,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -220420,13 +213363,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -220498,13 +213439,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -220595,13 +213534,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -220635,13 +213572,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -220675,13 +213610,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -220696,13 +213629,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -221002,13 +213933,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -221027,8 +213956,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -221053,13 +213981,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -221074,8 +214000,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -221159,13 +214084,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -221180,13 +214103,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -221201,8 +214122,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -221221,8 +214141,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -221241,8 +214160,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -221261,13 +214179,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -221292,13 +214208,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -221332,8 +214246,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -221409,13 +214322,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -221430,8 +214341,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -221526,13 +214436,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -221624,13 +214532,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -221645,13 +214551,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -221666,13 +214570,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -221687,13 +214589,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -221765,13 +214665,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -221862,13 +214760,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -221902,13 +214798,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -221942,13 +214836,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -221963,13 +214855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -222269,13 +215159,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -222294,8 +215182,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -222320,13 +215207,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -222341,8 +215226,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -222387,8 +215271,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                       "line": 196,
                       "column": 0,
                       "character": 7411
@@ -222412,8 +215295,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 7411
@@ -222428,13 +215310,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -222449,8 +215329,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -222469,8 +215348,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -222489,8 +215367,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -222509,13 +215386,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -222540,13 +215415,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -222580,8 +215453,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -222657,13 +215529,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -222678,8 +215548,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -222774,13 +215643,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -222872,13 +215739,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -222893,13 +215758,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -222914,13 +215777,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -222935,13 +215796,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -223013,13 +215872,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -223110,13 +215967,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -223150,13 +216005,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -223190,13 +216043,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -223211,13 +216062,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -223517,13 +216366,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -223542,8 +216389,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -223568,13 +216414,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -223589,8 +216433,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -223622,8 +216465,7 @@
       "Inference",
       {
         "current_goal_id": 1682,
-        "current_goal_text":
-          "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X213^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X213^2 | c6] c3)] =>\n copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n  X209^2",
+        "current_goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X213^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X213^2 | c6] c3)] =>\n copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n  X209^2",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -223634,8 +216476,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n X209^2",
+                "goal_text": "copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n X209^2",
                 "goal_id": 1688
               }
             ],
@@ -223653,13 +216494,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -223674,8 +216513,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -223694,8 +216532,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -223714,8 +216551,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -223734,13 +216570,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -223765,13 +216599,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -223805,8 +216637,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -223882,13 +216713,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -223903,8 +216732,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -223999,13 +216827,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -224097,13 +216923,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -224118,13 +216942,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -224139,13 +216961,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -224160,13 +216980,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -224238,13 +217056,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -224335,13 +217151,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -224375,13 +217189,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -224415,13 +217227,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -224436,13 +217246,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -224742,13 +217550,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -224767,8 +217573,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -224793,13 +217598,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -224814,8 +217617,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -224847,8 +217649,7 @@
       "Inference",
       {
         "current_goal_id": 1688,
-        "current_goal_text":
-          "copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n X209^2",
+        "current_goal_text": "copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n X209^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -224857,8 +217658,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X213^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X213^2 | A4] A1).",
+                  "rule_text": "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X213^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X213^2 | A4] A1).",
                   "rule_loc": [ "Context", 485 ]
                 }
               ],
@@ -224876,8 +217676,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "pack? (const «Builders_18.HB_unnamed_factory_22») _",
+                "goal_text": "pack? (const «Builders_18.HB_unnamed_factory_22») _",
                 "goal_id": 1689
               },
               { "goal_text": "!", "goal_id": 1690 },
@@ -224888,8 +217687,7 @@
               { "goal_text": "copy c0 X213^2", "goal_id": 1692 },
               { "goal_text": "std.map X218^2 copy X219^2", "goal_id": 1693 },
               {
-                "goal_text":
-                  "std.rev [global (const «elpi.hole»), X213^2 | X219^2] X216^2",
+                "goal_text": "std.rev [global (const «elpi.hole»), X213^2 | X219^2] X216^2",
                 "goal_id": 1694
               }
             ],
@@ -224902,8 +217700,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X213^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X213^2 | A4] A1).",
+                "rule_text": "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X213^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X213^2 | A4] A1).",
                 "rule_loc": [ "Context", 485 ]
               }
             ],
@@ -224919,13 +217716,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -224940,8 +217735,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -224960,8 +217754,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -224980,8 +217773,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -225000,13 +217792,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -225031,13 +217821,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -225071,8 +217859,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -225148,13 +217935,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -225169,8 +217954,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -225265,13 +218049,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -225363,13 +218145,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -225384,13 +218164,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -225405,13 +218183,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -225426,13 +218202,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -225504,13 +218278,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -225601,13 +218373,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -225641,13 +218411,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -225681,13 +218449,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -225702,13 +218468,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -226008,13 +218772,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -226033,8 +218795,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -226059,13 +218820,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -226080,8 +218839,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -226113,8 +218871,7 @@
       "Inference",
       {
         "current_goal_id": 1689,
-        "current_goal_text":
-          "pack? (const «Builders_18.HB_unnamed_factory_22») _",
+        "current_goal_text": "pack? (const «Builders_18.HB_unnamed_factory_22») _",
         "current_goal_predicate": "pack?",
         "failed_attempts": [],
         "successful_attempts": [],
@@ -226124,8 +218881,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X213^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X213^2 | A4] A1).",
+                "rule_text": "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X213^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X213^2 | A4] A1).",
                 "rule_loc": [ "Context", 485 ]
               }
             ],
@@ -226141,13 +218897,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -226162,8 +218916,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -226182,8 +218935,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -226202,8 +218954,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -226222,13 +218973,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -226253,13 +219002,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -226293,8 +219040,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -226370,13 +219116,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -226391,8 +219135,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -226487,13 +219230,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -226585,13 +219326,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -226606,13 +219345,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -226627,13 +219364,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -226648,13 +219383,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -226726,13 +219459,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -226823,13 +219554,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -226863,13 +219592,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -226903,13 +219630,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -226924,13 +219649,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -227230,13 +219953,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -227255,8 +219976,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -227281,13 +220001,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -227302,8 +220020,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -227335,8 +220052,7 @@
       "Inference",
       {
         "current_goal_id": 1688,
-        "current_goal_text":
-          "copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n X209^2",
+        "current_goal_text": "copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n X209^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -227345,8 +220061,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -227368,14 +220083,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "name (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1])",
+                "goal_text": "name (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1])",
                 "goal_id": 1695
               },
               { "goal_text": "!", "goal_id": 1696 },
               {
-                "goal_text":
-                  "app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1] = X209^2",
+                "goal_text": "app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1] = X209^2",
                 "goal_id": 1697
               },
               { "goal_text": "!", "goal_id": 1698 }
@@ -227389,8 +220102,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -227414,13 +220126,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -227435,8 +220145,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -227455,8 +220164,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -227475,8 +220183,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -227495,13 +220202,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -227526,13 +220231,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -227566,8 +220269,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -227643,13 +220345,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -227664,8 +220364,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -227760,13 +220459,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -227858,13 +220555,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -227879,13 +220574,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -227900,13 +220593,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -227921,13 +220612,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -227999,13 +220688,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -228096,13 +220783,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -228136,13 +220821,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -228176,13 +220859,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -228197,13 +220878,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -228503,13 +221182,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -228528,8 +221205,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -228554,13 +221230,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -228575,8 +221249,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -228608,8 +221281,7 @@
       "Inference",
       {
         "current_goal_id": 1695,
-        "current_goal_text":
-          "name (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1])",
+        "current_goal_text": "name (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1])",
         "current_goal_predicate": "name",
         "failed_attempts": [
           { "rule": [ "BuiltinRule", [ "FFI", "name" ] ], "events": [] }
@@ -228626,8 +221298,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -228651,13 +221322,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -228672,8 +221341,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -228692,8 +221360,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -228712,8 +221379,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -228732,13 +221398,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -228763,13 +221427,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -228803,8 +221465,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -228880,13 +221541,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -228901,8 +221560,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -228997,13 +221655,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -229095,13 +221751,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -229116,13 +221770,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -229137,13 +221789,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -229158,13 +221808,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -229236,13 +221884,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -229333,13 +221979,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -229373,13 +222017,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -229413,13 +222055,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -229434,13 +222074,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -229740,13 +222378,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -229765,8 +222401,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -229791,13 +222426,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -229812,8 +222445,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -229845,8 +222477,7 @@
       "Inference",
       {
         "current_goal_id": 1688,
-        "current_goal_text":
-          "copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n X209^2",
+        "current_goal_text": "copy (app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]) \n X209^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -229855,8 +222486,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                  "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -229879,8 +222509,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1699 },
               {
-                "goal_text":
-                  "std.map [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1] copy \n X220^2",
+                "goal_text": "std.map [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1] copy \n X220^2",
                 "goal_id": 1700
               }
             ],
@@ -229893,8 +222522,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -229918,13 +222546,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -229939,8 +222565,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -229959,8 +222584,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -229979,8 +222603,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -229999,13 +222622,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -230030,13 +222651,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -230070,8 +222689,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -230147,13 +222765,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -230168,8 +222784,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -230264,13 +222879,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -230362,13 +222975,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -230383,13 +222994,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -230404,13 +223013,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -230425,13 +223032,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -230503,13 +223108,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -230600,13 +223203,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -230640,13 +223241,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -230680,13 +223279,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -230701,13 +223298,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -231007,13 +223602,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -231032,8 +223625,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -231058,13 +223650,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -231079,8 +223669,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -231118,8 +223707,7 @@
       "Inference",
       {
         "current_goal_id": 1700,
-        "current_goal_text":
-          "std.map [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1] copy \n X220^2",
+        "current_goal_text": "std.map [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1] copy \n X220^2",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -231128,8 +223716,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -231153,8 +223740,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "copy (global (const «Builders_18.HB_unnamed_factory_22»)) X221^2",
+                "goal_text": "copy (global (const «Builders_18.HB_unnamed_factory_22»)) X221^2",
                 "goal_id": 1701
               },
               {
@@ -231171,8 +223757,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -231191,8 +223776,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -231216,13 +223800,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -231237,8 +223819,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -231257,8 +223838,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -231277,8 +223857,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -231297,13 +223876,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -231328,13 +223905,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -231368,8 +223943,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -231445,13 +224019,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -231466,8 +224038,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -231562,13 +224133,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -231660,13 +224229,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -231681,13 +224248,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -231702,13 +224267,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -231723,13 +224286,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -231801,13 +224362,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -231898,13 +224457,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -231938,13 +224495,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -231978,13 +224533,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -231999,13 +224552,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -232305,13 +224856,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -232330,8 +224879,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -232356,13 +224904,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -232377,8 +224923,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -232410,8 +224955,7 @@
       "Inference",
       {
         "current_goal_id": 1701,
-        "current_goal_text":
-          "copy (global (const «Builders_18.HB_unnamed_factory_22»)) X221^2",
+        "current_goal_text": "copy (global (const «Builders_18.HB_unnamed_factory_22»)) X221^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -232420,8 +224964,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -232443,14 +224986,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "name (global (const «Builders_18.HB_unnamed_factory_22»))",
+                "goal_text": "name (global (const «Builders_18.HB_unnamed_factory_22»))",
                 "goal_id": 1703
               },
               { "goal_text": "!", "goal_id": 1704 },
               {
-                "goal_text":
-                  "global (const «Builders_18.HB_unnamed_factory_22») = X221^2",
+                "goal_text": "global (const «Builders_18.HB_unnamed_factory_22») = X221^2",
                 "goal_id": 1705
               },
               { "goal_text": "!", "goal_id": 1706 }
@@ -232464,8 +225005,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -232484,8 +225024,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -232504,8 +225043,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -232529,13 +225067,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -232550,8 +225086,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -232570,8 +225105,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -232590,8 +225124,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -232610,13 +225143,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -232641,13 +225172,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -232681,8 +225210,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -232758,13 +225286,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -232779,8 +225305,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -232875,13 +225400,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -232973,13 +225496,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -232994,13 +225515,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -233015,13 +225534,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -233036,13 +225553,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -233114,13 +225629,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -233211,13 +225724,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -233251,13 +225762,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -233291,13 +225800,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -233312,13 +225819,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -233618,13 +226123,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -233643,8 +226146,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -233669,13 +226171,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -233690,8 +226190,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -233723,8 +226222,7 @@
       "Inference",
       {
         "current_goal_id": 1703,
-        "current_goal_text":
-          "name (global (const «Builders_18.HB_unnamed_factory_22»))",
+        "current_goal_text": "name (global (const «Builders_18.HB_unnamed_factory_22»))",
         "current_goal_predicate": "name",
         "failed_attempts": [
           { "rule": [ "BuiltinRule", [ "FFI", "name" ] ], "events": [] }
@@ -233741,8 +226239,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -233761,8 +226258,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -233781,8 +226277,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -233806,13 +226301,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -233827,8 +226320,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -233847,8 +226339,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -233867,8 +226358,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -233887,13 +226377,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -233918,13 +226406,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -233958,8 +226444,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -234035,13 +226520,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -234056,8 +226539,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -234152,13 +226634,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -234250,13 +226730,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -234271,13 +226749,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -234292,13 +226768,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -234313,13 +226787,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -234391,13 +226863,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -234488,13 +226958,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -234528,13 +226996,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -234568,13 +227034,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -234589,13 +227053,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -234895,13 +227357,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -234920,8 +227380,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -234946,13 +227405,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -234967,8 +227424,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -235000,8 +227456,7 @@
       "Inference",
       {
         "current_goal_id": 1701,
-        "current_goal_text":
-          "copy (global (const «Builders_18.HB_unnamed_factory_22»)) X221^2",
+        "current_goal_text": "copy (global (const «Builders_18.HB_unnamed_factory_22»)) X221^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -235062,8 +227517,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -235082,8 +227536,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -235107,13 +227560,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -235128,8 +227579,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -235148,8 +227598,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -235168,8 +227617,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -235188,13 +227636,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -235219,13 +227665,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -235259,8 +227703,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -235336,13 +227779,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -235357,8 +227798,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -235453,13 +227893,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -235551,13 +227989,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -235572,13 +228008,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -235593,13 +228027,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -235614,13 +228046,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -235692,13 +228122,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -235789,13 +228217,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -235829,13 +228255,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -235869,13 +228293,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -235890,13 +228312,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -236196,13 +228616,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -236221,8 +228639,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -236247,13 +228664,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -236268,8 +228683,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -236316,8 +228730,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -236349,8 +228762,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -236369,8 +228781,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -236389,8 +228800,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -236414,13 +228824,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -236435,8 +228843,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -236455,8 +228862,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -236475,8 +228881,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -236495,13 +228900,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -236526,13 +228929,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -236566,8 +228967,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -236643,13 +229043,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -236664,8 +229062,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -236760,13 +229157,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -236858,13 +229253,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -236879,13 +229272,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -236900,13 +229291,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -236921,13 +229310,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -236999,13 +229386,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -237096,13 +229481,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -237136,13 +229519,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -237176,13 +229557,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -237197,13 +229576,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -237503,13 +229880,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -237528,8 +229903,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -237554,13 +229928,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -237575,8 +229947,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -237617,8 +229988,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -237631,8 +230001,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := c0" ],
-                [ "Assign", "A1 := X223^2" ]
+                [ "Assign", "A0 := c0" ], [ "Assign", "A1 := X223^2" ]
               ]
             },
             "siblings": [
@@ -237650,8 +230019,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -237670,8 +230038,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -237690,8 +230057,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -237710,8 +230076,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -237735,13 +230100,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -237756,8 +230119,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -237776,8 +230138,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -237796,8 +230157,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -237816,13 +230176,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -237847,13 +230205,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -237887,8 +230243,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -237964,13 +230319,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -237985,8 +230338,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -238081,13 +230433,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -238179,13 +230529,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -238200,13 +230548,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -238221,13 +230567,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -238242,13 +230586,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -238320,13 +230662,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -238417,13 +230757,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -238457,13 +230795,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -238497,13 +230833,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -238518,13 +230852,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -238824,13 +231156,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -238849,8 +231179,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -238875,13 +231204,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -238896,8 +231223,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -238953,8 +231279,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -238973,8 +231298,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -238993,8 +231317,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -239013,8 +231336,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -239038,13 +231360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -239059,8 +231379,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -239079,8 +231398,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -239099,8 +231417,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -239119,13 +231436,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -239150,13 +231465,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -239190,8 +231503,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -239267,13 +231579,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -239288,8 +231598,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -239384,13 +231693,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -239482,13 +231789,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -239503,13 +231808,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -239524,13 +231827,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -239545,13 +231846,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -239623,13 +231922,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -239720,13 +232017,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -239760,13 +232055,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -239800,13 +232093,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -239821,13 +232112,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -240127,13 +232416,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -240152,8 +232439,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -240178,13 +232464,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -240199,8 +232483,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -240261,8 +232544,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -240281,8 +232563,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -240301,8 +232582,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -240321,8 +232601,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -240346,13 +232625,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -240367,8 +232644,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -240387,8 +232663,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -240407,8 +232682,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -240427,13 +232701,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -240458,13 +232730,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -240498,8 +232768,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -240575,13 +232844,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -240596,8 +232863,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -240692,13 +232958,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -240790,13 +233054,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -240811,13 +233073,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -240832,13 +233092,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -240853,13 +233111,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -240931,13 +233187,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -241028,13 +233282,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -241068,13 +233320,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -241108,13 +233358,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -241129,13 +233377,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -241435,13 +233681,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -241460,8 +233704,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -241486,13 +233729,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -241507,8 +233748,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -241570,8 +233810,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -241590,8 +233829,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -241610,8 +233848,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -241630,8 +233867,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -241655,13 +233891,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -241676,8 +233910,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -241696,8 +233929,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -241716,8 +233948,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -241736,13 +233967,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -241767,13 +233996,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -241807,8 +234034,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -241884,13 +234110,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -241905,8 +234129,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -242001,13 +234224,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -242099,13 +234320,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -242120,13 +234339,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -242141,13 +234358,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -242162,13 +234377,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -242240,13 +234453,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -242337,13 +234548,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -242377,13 +234586,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -242417,13 +234624,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -242438,13 +234643,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -242744,13 +234947,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -242769,8 +234970,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -242795,13 +234995,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -242816,8 +235014,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -242864,8 +235061,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -242897,8 +235093,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -242917,8 +235112,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -242937,8 +235131,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -242957,8 +235150,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -242982,13 +235174,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -243003,8 +235193,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -243023,8 +235212,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -243043,8 +235231,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -243063,13 +235250,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -243094,13 +235279,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -243134,8 +235317,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -243211,13 +235393,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -243232,8 +235412,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -243328,13 +235507,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -243426,13 +235603,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -243447,13 +235622,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -243468,13 +235641,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -243489,13 +235660,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -243567,13 +235736,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -243664,13 +235831,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -243704,13 +235869,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -243744,13 +235907,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -243765,13 +235926,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -244071,13 +236230,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -244096,8 +236253,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -244122,13 +236278,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -244143,8 +236297,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -244185,8 +236338,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -244199,8 +236351,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := c1" ],
-                [ "Assign", "A1 := X225^2" ]
+                [ "Assign", "A0 := c1" ], [ "Assign", "A1 := X225^2" ]
               ]
             },
             "siblings": [
@@ -244218,8 +236369,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -244238,8 +236388,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -244258,8 +236407,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -244278,8 +236426,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -244298,8 +236445,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -244323,13 +236469,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -244344,8 +236488,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -244364,8 +236507,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -244384,8 +236526,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -244404,13 +236545,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -244435,13 +236574,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -244475,8 +236612,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -244552,13 +236688,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -244573,8 +236707,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -244669,13 +236802,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -244767,13 +236898,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -244788,13 +236917,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -244809,13 +236936,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -244830,13 +236955,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -244908,13 +237031,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -245005,13 +237126,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -245045,13 +237164,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -245085,13 +237202,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -245106,13 +237221,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -245412,13 +237525,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -245437,8 +237548,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -245463,13 +237573,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -245484,8 +237592,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -245541,8 +237648,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -245561,8 +237667,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -245581,8 +237686,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -245601,8 +237705,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -245621,8 +237724,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -245646,13 +237748,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -245667,8 +237767,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -245687,8 +237786,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -245707,8 +237805,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -245727,13 +237824,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -245758,13 +237853,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -245798,8 +237891,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -245875,13 +237967,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -245896,8 +237986,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -245992,13 +238081,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -246090,13 +238177,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -246111,13 +238196,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -246132,13 +238215,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -246153,13 +238234,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -246231,13 +238310,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -246328,13 +238405,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -246368,13 +238443,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -246408,13 +238481,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -246429,13 +238500,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -246735,13 +238804,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -246760,8 +238827,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -246786,13 +238852,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -246807,8 +238871,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -246869,8 +238932,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -246889,8 +238951,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -246909,8 +238970,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -246929,8 +238989,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -246949,8 +239008,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -246974,13 +239032,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -246995,8 +239051,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -247015,8 +239070,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -247035,8 +239089,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -247055,13 +239108,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -247086,13 +239137,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -247126,8 +239175,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -247203,13 +239251,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -247224,8 +239270,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -247320,13 +239365,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -247418,13 +239461,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -247439,13 +239480,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -247460,13 +239499,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -247481,13 +239518,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -247559,13 +239594,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -247656,13 +239689,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -247696,13 +239727,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -247736,13 +239765,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -247757,13 +239784,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -248063,13 +240088,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -248088,8 +240111,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -248114,13 +240136,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -248135,8 +240155,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -248198,8 +240217,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -248218,8 +240236,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -248238,8 +240255,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -248258,8 +240274,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -248278,8 +240293,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -248303,13 +240317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -248324,8 +240336,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -248344,8 +240355,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -248364,8 +240374,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -248384,13 +240393,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -248415,13 +240422,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -248455,8 +240460,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -248532,13 +240536,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -248553,8 +240555,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -248649,13 +240650,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -248747,13 +240746,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -248768,13 +240765,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -248789,13 +240784,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -248810,13 +240803,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -248888,13 +240879,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -248985,13 +240974,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -249025,13 +241012,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -249065,13 +241050,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -249086,13 +241069,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -249392,13 +241373,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -249417,8 +241396,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -249443,13 +241421,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -249464,8 +241440,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -249555,8 +241530,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -249575,8 +241549,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -249595,8 +241568,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -249615,8 +241587,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -249640,13 +241611,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -249661,8 +241630,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -249681,8 +241649,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -249701,8 +241668,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -249721,13 +241687,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -249752,13 +241716,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -249792,8 +241754,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -249869,13 +241830,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -249890,8 +241849,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -249986,13 +241944,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -250084,13 +242040,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -250105,13 +242059,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -250126,13 +242078,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -250147,13 +242097,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -250225,13 +242173,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -250322,13 +242268,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -250362,13 +242306,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -250402,13 +242344,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -250423,13 +242363,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -250729,13 +242667,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -250754,8 +242690,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -250780,13 +242715,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -250801,8 +242734,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -250886,8 +242818,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -250906,8 +242837,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -250926,8 +242856,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -250946,13 +242875,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -250977,13 +242904,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -251017,8 +242942,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -251094,13 +243018,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -251115,8 +243037,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -251211,13 +243132,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -251309,13 +243228,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -251330,13 +243247,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -251351,13 +243266,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -251372,13 +243285,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -251450,13 +243361,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -251547,13 +243456,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -251587,13 +243494,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -251627,13 +243532,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -251648,13 +243551,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -251954,13 +243855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -251979,8 +243878,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -252005,13 +243903,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -252026,8 +243922,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -252059,8 +243954,7 @@
       "Inference",
       {
         "current_goal_id": 1613,
-        "current_goal_text":
-          "std.spy\n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
+        "current_goal_text": "std.spy\n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
         "current_goal_predicate": "std.spy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -252069,8 +243963,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                  "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                   "rule_loc": [
                     "File",
                     {
@@ -252092,23 +243985,19 @@
             "siblings": [
               { "goal_text": "trace.counter run X227^2", "goal_id": 1722 },
               {
-                "goal_text":
-                  "if (not (X227^2 = 0)) (std.debug-print run= X227^2) true",
+                "goal_text": "if (not (X227^2 = 0)) (std.debug-print run= X227^2) true",
                 "goal_id": 1723
               },
               {
-                "goal_text":
-                  "std.debug-print ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
+                "goal_text": "std.debug-print ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
                 "goal_id": 1724
               },
               {
-                "goal_text":
-                  "std.take 0 \n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] X175^1",
+                "goal_text": "std.take 0 \n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] X175^1",
                 "goal_id": 1725
               },
               {
-                "goal_text":
-                  "std.debug-print ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
+                "goal_text": "std.debug-print ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
                 "goal_id": 1726
               }
             ],
@@ -252121,8 +244010,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -252141,13 +244029,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -252172,13 +244058,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -252212,8 +244096,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -252289,13 +244172,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -252310,8 +244191,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -252406,13 +244286,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -252504,13 +244382,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -252525,13 +244401,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -252546,13 +244420,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -252567,13 +244439,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -252645,13 +244515,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -252742,13 +244610,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -252782,13 +244648,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -252822,13 +244686,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -252843,13 +244705,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -253149,13 +245009,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -253174,8 +245032,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -253200,13 +245057,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -253221,8 +245076,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -253278,8 +245132,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -253298,13 +245151,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -253329,13 +245180,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -253369,8 +245218,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -253446,13 +245294,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -253467,8 +245313,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -253563,13 +245408,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -253661,13 +245504,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -253682,13 +245523,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -253703,13 +245542,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -253724,13 +245561,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -253802,13 +245637,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -253899,13 +245732,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -253939,13 +245770,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -253979,13 +245808,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -254000,13 +245827,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -254306,13 +246131,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -254331,8 +246154,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -254357,13 +246179,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -254378,8 +246198,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -254440,8 +246259,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -254460,13 +246278,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -254491,13 +246307,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -254531,8 +246345,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -254608,13 +246421,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -254629,8 +246440,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -254725,13 +246535,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -254823,13 +246631,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -254844,13 +246650,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -254865,13 +246669,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -254886,13 +246688,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -254964,13 +246764,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -255061,13 +246859,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -255101,13 +246897,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -255141,13 +246935,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -255162,13 +246954,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -255468,13 +247258,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -255493,8 +247281,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -255519,13 +247306,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -255540,8 +247325,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -255632,8 +247416,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -255652,13 +247435,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -255683,13 +247464,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -255723,8 +247502,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -255800,13 +247578,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -255821,8 +247597,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -255917,13 +247692,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -256015,13 +247788,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -256036,13 +247807,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -256057,13 +247826,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -256078,13 +247845,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -256156,13 +247921,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -256253,13 +248016,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -256293,13 +248054,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -256333,13 +248092,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -256354,13 +248111,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -256660,13 +248415,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -256685,8 +248438,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -256711,13 +248463,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -256732,8 +248482,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -256840,8 +248589,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -256860,13 +248608,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -256891,13 +248637,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -256931,8 +248675,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -257008,13 +248751,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -257029,8 +248770,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -257125,13 +248865,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -257223,13 +248961,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -257244,13 +248980,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -257265,13 +248999,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -257286,13 +249018,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -257364,13 +249094,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -257461,13 +249189,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -257501,13 +249227,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -257541,13 +249265,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -257562,13 +249284,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -257868,13 +249588,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -257893,8 +249611,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -257919,13 +249636,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -257940,8 +249655,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -258035,8 +249749,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -258055,13 +249768,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -258086,13 +249797,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -258126,8 +249835,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -258203,13 +249911,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -258224,8 +249930,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -258320,13 +250025,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -258418,13 +250121,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -258439,13 +250140,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -258460,13 +250159,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -258481,13 +250178,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -258559,13 +250254,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -258656,13 +250349,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -258696,13 +250387,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -258736,13 +250425,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -258757,13 +250444,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -259063,13 +250748,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -259088,8 +250771,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -259114,13 +250796,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -259135,8 +250815,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -259247,8 +250926,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -259267,13 +250945,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -259298,13 +250974,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -259338,8 +251012,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -259415,13 +251088,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -259436,8 +251107,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -259532,13 +251202,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -259630,13 +251298,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -259651,13 +251317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -259672,13 +251336,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -259693,13 +251355,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -259771,13 +251431,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -259868,13 +251526,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -259908,13 +251564,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -259948,13 +251602,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -259969,13 +251621,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -260275,13 +251925,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -260300,8 +251948,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -260326,13 +251973,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -260347,8 +251992,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -260432,8 +252076,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -260452,13 +252095,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -260483,13 +252124,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -260523,8 +252162,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -260600,13 +252238,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -260621,8 +252257,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -260717,13 +252352,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -260815,13 +252448,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -260836,13 +252467,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -260857,13 +252486,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -260878,13 +252505,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -260956,13 +252581,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -261053,13 +252676,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -261093,13 +252714,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -261133,13 +252752,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -261154,13 +252771,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -261460,13 +253075,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -261485,8 +253098,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -261511,13 +253123,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -261532,8 +253142,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -261636,8 +253245,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -261656,13 +253264,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -261687,13 +253293,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -261727,8 +253331,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -261804,13 +253407,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -261825,8 +253426,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -261921,13 +253521,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -262019,13 +253617,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -262040,13 +253636,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -262061,13 +253655,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -262082,13 +253674,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -262160,13 +253750,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -262257,13 +253845,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -262297,13 +253883,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -262337,13 +253921,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -262358,13 +253940,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -262664,13 +254244,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -262689,8 +254267,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -262715,13 +254292,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -262736,8 +254311,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -262769,8 +254343,7 @@
       "Inference",
       {
         "current_goal_id": 1724,
-        "current_goal_text":
-          "std.debug-print ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
+        "current_goal_text": "std.debug-print ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
         "current_goal_predicate": "std.debug-print",
         "failed_attempts": [],
         "successful_attempts": [
@@ -262779,8 +254352,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
+                  "rule_text": "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -262803,8 +254375,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1735 },
               {
-                "goal_text":
-                  "coq.say ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
+                "goal_text": "coq.say ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
                 "goal_id": 1736
               }
             ],
@@ -262817,8 +254388,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
+                "rule_text": "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -262837,8 +254407,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -262857,13 +254426,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -262888,13 +254455,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -262928,8 +254493,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -263005,13 +254569,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -263026,8 +254588,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -263122,13 +254683,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -263220,13 +254779,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -263241,13 +254798,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -263262,13 +254817,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -263283,13 +254836,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -263361,13 +254912,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -263458,13 +255007,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -263498,13 +255045,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -263538,13 +255083,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -263559,13 +255102,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -263865,13 +255406,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -263890,8 +255429,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -263916,13 +255454,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -263937,8 +255473,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -263973,8 +255508,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.debug-print ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
+              "goal_text": "std.debug-print ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
               "goal_id": 1724
             },
             "cut_branch": {
@@ -264002,8 +255536,7 @@
       "Inference",
       {
         "current_goal_id": 1736,
-        "current_goal_text":
-          "coq.say ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
+        "current_goal_text": "coq.say ----<<---- enter:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
         "current_goal_predicate": "coq.say",
         "failed_attempts": [],
         "successful_attempts": [
@@ -264027,8 +255560,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
+                "rule_text": "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -264047,8 +255579,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -264067,13 +255598,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -264098,13 +255627,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -264138,8 +255665,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -264215,13 +255741,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -264236,8 +255760,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -264332,13 +255855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -264430,13 +255951,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -264451,13 +255970,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -264472,13 +255989,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -264493,13 +256008,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -264571,13 +256084,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -264668,13 +256179,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -264708,13 +256217,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -264748,13 +256255,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -264769,13 +256274,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -265075,13 +256578,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -265100,8 +256601,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -265126,13 +256626,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -265147,8 +256645,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -265180,8 +256677,7 @@
       "Inference",
       {
         "current_goal_id": 1725,
-        "current_goal_text":
-          "std.take 0 \n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] X175^1",
+        "current_goal_text": "std.take 0 \n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] X175^1",
         "current_goal_predicate": "std.take",
         "failed_attempts": [],
         "successful_attempts": [
@@ -265233,8 +256729,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -265253,13 +256748,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -265284,13 +256777,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -265324,8 +256815,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -265401,13 +256891,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -265422,8 +256910,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -265518,13 +257005,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -265616,13 +257101,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -265637,13 +257120,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -265658,13 +257139,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -265679,13 +257158,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -265757,13 +257234,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -265854,13 +257329,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -265894,13 +257367,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -265934,13 +257405,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -265955,13 +257424,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -266261,13 +257728,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -266286,8 +257751,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -266312,13 +257776,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -266333,8 +257795,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -266369,13 +257830,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.take 0 \n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] X175^1",
+              "goal_text": "std.take 0 \n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] X175^1",
               "goal_id": 1725
             },
             "cut_branch": {
-              "rule_text":
-                "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
+              "rule_text": "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
               "rule_loc": [
                 "File",
                 {
@@ -266389,13 +257848,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.take 0 \n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] X175^1",
+              "goal_text": "std.take 0 \n [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n  app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] X175^1",
               "goal_id": 1725
             },
             "cut_branch": {
-              "rule_text":
-                "(std.take _ _ _) :- (std.fatal-error take run out of list items).",
+              "rule_text": "(std.take _ _ _) :- (std.fatal-error take run out of list items).",
               "rule_loc": [
                 "File",
                 {
@@ -266419,8 +257876,7 @@
       "Inference",
       {
         "current_goal_id": 1726,
-        "current_goal_text":
-          "std.debug-print ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] [])",
+        "current_goal_text": "std.debug-print ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] [])",
         "current_goal_predicate": "std.debug-print",
         "failed_attempts": [],
         "successful_attempts": [
@@ -266429,8 +257885,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
+                  "rule_text": "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -266453,8 +257908,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1738 },
               {
-                "goal_text":
-                  "coq.say ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] [])",
+                "goal_text": "coq.say ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] [])",
                 "goal_id": 1739
               }
             ],
@@ -266467,8 +257921,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
+                "rule_text": "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -266487,8 +257940,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -266507,13 +257959,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -266538,13 +257988,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -266578,8 +258026,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -266655,13 +258102,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -266676,8 +258121,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -266772,13 +258216,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -266870,13 +258312,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -266891,13 +258331,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -266912,13 +258350,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -266933,13 +258369,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -267011,13 +258445,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -267108,13 +258540,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -267148,13 +258578,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -267188,13 +258616,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -267209,13 +258635,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -267515,13 +258939,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -267540,8 +258962,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -267566,13 +258987,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -267587,8 +259006,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -267623,8 +259041,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.debug-print ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
+              "goal_text": "std.debug-print ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] \n   X175^1)",
               "goal_id": 1726
             },
             "cut_branch": {
@@ -267652,8 +259069,7 @@
       "Inference",
       {
         "current_goal_id": 1739,
-        "current_goal_text":
-          "coq.say ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] [])",
+        "current_goal_text": "coq.say ---->>---- exit:  \n (std.take 0 \n   [c0, app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n    app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]] [])",
         "current_goal_predicate": "coq.say",
         "failed_attempts": [],
         "successful_attempts": [
@@ -267677,8 +259093,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
+                "rule_text": "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -267697,8 +259112,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -267717,13 +259131,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -267748,13 +259160,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -267788,8 +259198,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -267865,13 +259274,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -267886,8 +259293,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -267982,13 +259388,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -268080,13 +259484,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -268101,13 +259503,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -268122,13 +259522,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -268143,13 +259541,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -268221,13 +259617,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -268318,13 +259712,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -268358,13 +259750,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -268398,13 +259788,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -268419,13 +259807,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -268725,13 +260111,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -268750,8 +260134,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -268776,13 +260159,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -268797,8 +260178,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -268837,8 +260217,7 @@
               "goal_id": 1613
             },
             "cut_branch": {
-              "rule_text":
-                "(std.spy A0) :- (std.debug-print ---->>---- fail:  A0), fail.",
+              "rule_text": "(std.spy A0) :- (std.debug-print ---->>---- fail:  A0), fail.",
               "rule_loc": [
                 "File",
                 {
@@ -268856,8 +260235,7 @@
               "goal_id": 1611
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-nparams (indt «SelfA.axioms_») 0) :- .",
+              "rule_text": "(factory-nparams (indt «SelfA.axioms_») 0) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -268875,8 +260253,7 @@
               "goal_id": 1611
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-nparams (indt «IsSelfA'.axioms_») 0) :- .",
+              "rule_text": "(factory-nparams (indt «IsSelfA'.axioms_») 0) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -268890,8 +260267,7 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «IsSelfA.axioms_»), c0, \n        app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n        app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n    X175^1)",
+              "goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «IsSelfA.axioms_»), c0, \n     app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n     app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n X175^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «IsSelfA.axioms_»), c0, \n        app [global (const «Builders_18.HB_unnamed_factory_20»), c0, c1], \n        app [global (const «Builders_18.HB_unnamed_factory_22»), c0, c1]]) \n    X175^1)",
               "goal_id": 1602
             },
             "cut_branch": {
@@ -269034,13 +260410,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -269055,8 +260429,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -269151,13 +260524,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -269249,13 +260620,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -269270,13 +260639,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -269291,13 +260658,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -269312,13 +260677,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -269390,13 +260753,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -269487,13 +260848,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -269527,13 +260886,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -269567,13 +260924,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -269588,13 +260943,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -269894,13 +261247,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -269919,8 +261270,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -269945,13 +261295,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -269966,8 +261314,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -269999,8 +261346,7 @@
       "Inference",
       {
         "current_goal_id": 1578,
-        "current_goal_text":
-          "std.map2\n [global (const «Builders_18.HB_unnamed_factory_22»), \n  global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «HasB.axioms_», indt «HasA.axioms_»] (factory-provides.one [] c0) \n X174^1",
+        "current_goal_text": "std.map2\n [global (const «Builders_18.HB_unnamed_factory_22»), \n  global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «HasB.axioms_», indt «HasA.axioms_»] (factory-provides.one [] c0) \n X174^1",
         "current_goal_predicate": "std.map2",
         "failed_attempts": [],
         "successful_attempts": [
@@ -270009,8 +261355,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                  "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                   "rule_loc": [
                     "File",
                     {
@@ -270039,13 +261384,11 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "factory-provides.one [] c0 \n (global (const «Builders_18.HB_unnamed_factory_22»)) \n (indt «HasB.axioms_») X228^1",
+                "goal_text": "factory-provides.one [] c0 \n (global (const «Builders_18.HB_unnamed_factory_22»)) \n (indt «HasB.axioms_») X228^1",
                 "goal_id": 1740
               },
               {
-                "goal_text":
-                  "std.map2 [global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «HasA.axioms_»] (factory-provides.one [] c0) X229^1",
+                "goal_text": "std.map2 [global (const «Builders_18.HB_unnamed_factory_20»)] \n [indt «HasA.axioms_»] (factory-provides.one [] c0) X229^1",
                 "goal_id": 1741
               }
             ],
@@ -270058,8 +261401,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -270078,8 +261420,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -270174,13 +261515,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -270272,13 +261611,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -270293,13 +261630,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -270314,13 +261649,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -270335,13 +261668,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -270413,13 +261744,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -270510,13 +261839,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -270550,13 +261877,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -270590,13 +261915,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -270611,13 +261934,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -270917,13 +262238,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -270942,8 +262261,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -270968,13 +262286,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -270989,8 +262305,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -271022,8 +262337,7 @@
       "Inference",
       {
         "current_goal_id": 1740,
-        "current_goal_text":
-          "factory-provides.one [] c0 \n (global (const «Builders_18.HB_unnamed_factory_22»)) \n (indt «HasB.axioms_») X228^1",
+        "current_goal_text": "factory-provides.one [] c0 \n (global (const «Builders_18.HB_unnamed_factory_22»)) \n (indt «HasB.axioms_») X228^1",
         "current_goal_predicate": "factory-provides.one",
         "failed_attempts": [],
         "successful_attempts": [
@@ -271032,13 +262346,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                  "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 108,
                       "column": 0,
                       "character": 3601
@@ -271062,8 +262374,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) \n     X231^1) Builder illtyped, \n  (coq.subst-prod [] X231^1 X232^1 , coq.subst-prod [c0] X232^1 X233^1), \n  std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+                "goal_text": "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) \n     X231^1) Builder illtyped, \n  (coq.subst-prod [] X231^1 X232^1 , coq.subst-prod [c0] X232^1 X233^1), \n  std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
                 "goal_id": 1742
               }
             ],
@@ -271076,13 +262387,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -271097,8 +262406,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -271117,8 +262425,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -271213,13 +262520,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -271311,13 +262616,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -271332,13 +262635,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -271353,13 +262654,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -271374,13 +262673,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -271452,13 +262749,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -271549,13 +262844,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -271589,13 +262882,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -271629,13 +262920,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -271650,13 +262939,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -271956,13 +263243,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -271981,8 +263266,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -272007,13 +263291,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -272028,8 +263310,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -272061,8 +263342,7 @@
       "Inference",
       {
         "current_goal_id": 1742,
-        "current_goal_text":
-          "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) \n     X231^1) Builder illtyped, \n  (coq.subst-prod [] X231^1 X232^1 , coq.subst-prod [c0] X232^1 X233^1), \n  std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+        "current_goal_text": "std.do!\n [std.assert-ok!\n   (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) \n     X231^1) Builder illtyped, \n  (coq.subst-prod [] X231^1 X232^1 , coq.subst-prod [c0] X232^1 X233^1), \n  std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -272071,8 +263351,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -272097,14 +263376,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1) \n Builder illtyped",
+                "goal_text": "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1) \n Builder illtyped",
                 "goal_id": 1743
               },
               { "goal_text": "!", "goal_id": 1744 },
               {
-                "goal_text":
-                  "std.do!\n [(coq.subst-prod [] X231^1 X232^1 , coq.subst-prod [c0] X232^1 X233^1), \n  std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+                "goal_text": "std.do!\n [(coq.subst-prod [] X231^1 X232^1 , coq.subst-prod [c0] X232^1 X233^1), \n  std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
                 "goal_id": 1745
               }
             ],
@@ -272136,13 +263413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -272157,8 +263432,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -272177,8 +263451,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -272273,13 +263546,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -272371,13 +263642,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -272392,13 +263661,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -272413,13 +263680,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -272434,13 +263699,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -272512,13 +263775,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -272609,13 +263870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -272649,13 +263908,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -272689,13 +263946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -272710,13 +263965,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -273016,13 +264269,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -273041,8 +264292,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -273067,13 +264317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -273088,8 +264336,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -273121,8 +264368,7 @@
       "Inference",
       {
         "current_goal_id": 1743,
-        "current_goal_text":
-          "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1) \n Builder illtyped",
+        "current_goal_text": "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1) \n Builder illtyped",
         "current_goal_predicate": "std.assert-ok!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -273131,8 +264377,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                  "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -273154,14 +264399,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1 \n X234^1",
+                "goal_text": "coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1 \n X234^1",
                 "goal_id": 1746
               },
               { "goal_text": "!", "goal_id": 1747 },
               {
-                "goal_text":
-                  "X234^1 = ok ;\n X234^1 = error X235^1 , std.fatal-error-w-data Builder illtyped X235^1",
+                "goal_text": "X234^1 = ok ;\n X234^1 = error X235^1 , std.fatal-error-w-data Builder illtyped X235^1",
                 "goal_id": 1748
               },
               { "goal_text": "!", "goal_id": 1749 }
@@ -273175,8 +264418,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -273214,13 +264456,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -273235,8 +264475,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -273255,8 +264494,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -273351,13 +264589,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -273449,13 +264685,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -273470,13 +264704,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -273491,13 +264723,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -273512,13 +264742,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -273590,13 +264818,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -273687,13 +264913,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -273727,13 +264951,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -273767,13 +264989,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -273788,13 +265008,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -274094,13 +265312,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -274119,8 +265335,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -274145,13 +265360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -274166,8 +265379,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -274199,8 +265411,7 @@
       "Inference",
       {
         "current_goal_id": 1746,
-        "current_goal_text":
-          "coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1 \n X234^1",
+        "current_goal_text": "coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1 \n X234^1",
         "current_goal_predicate": "coq.typecheck",
         "failed_attempts": [],
         "successful_attempts": [
@@ -274211,8 +265422,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "X231^1 =\n prod `T` (sort (typ «interleave_context.396»)) c1 \\\n  prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n   c2 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c1, c2], c1]",
+                "goal_text": "X231^1 =\n prod `T` (sort (typ «interleave_context.396»)) c1 \\\n  prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n   c2 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c1, c2], c1]",
                 "goal_id": 1750
               },
               { "goal_text": "X234^1 = ok", "goal_id": 1751 }
@@ -274231,8 +265441,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -274270,13 +265479,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -274291,8 +265498,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -274311,8 +265517,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -274407,13 +265612,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -274505,13 +265708,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -274526,13 +265727,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -274547,13 +265746,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -274568,13 +265765,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -274646,13 +265841,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -274743,13 +265936,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -274783,13 +265974,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -274823,13 +266012,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -274844,13 +266031,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -275150,13 +266335,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -275175,8 +266358,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -275201,13 +266383,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -275222,8 +266402,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -275255,8 +266434,7 @@
       "Inference",
       {
         "current_goal_id": 1750,
-        "current_goal_text":
-          "X231^1 =\n prod `T` (sort (typ «interleave_context.396»)) c1 \\\n  prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n   c2 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c1, c2], c1]",
+        "current_goal_text": "X231^1 =\n prod `T` (sort (typ «interleave_context.396»)) c1 \\\n  prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n   c2 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c1, c2], c1]",
         "current_goal_predicate": "=",
         "failed_attempts": [],
         "successful_attempts": [
@@ -275290,8 +266468,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -275329,13 +266506,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -275350,8 +266525,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -275370,8 +266544,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -275466,13 +266639,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -275564,13 +266735,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -275585,13 +266754,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -275606,13 +266773,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -275627,13 +266792,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -275705,13 +266868,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -275802,13 +266963,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -275842,13 +267001,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -275882,13 +267039,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -275903,13 +267058,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -276209,13 +267362,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -276234,8 +267385,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -276260,13 +267410,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -276281,8 +267429,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -276343,8 +267490,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -276382,13 +267528,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -276403,8 +267547,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -276423,8 +267566,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -276519,13 +267661,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -276617,13 +267757,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -276638,13 +267776,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -276659,13 +267795,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -276680,13 +267814,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -276758,13 +267890,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -276855,13 +267985,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -276895,13 +268023,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -276935,13 +268061,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -276956,13 +268080,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -277262,13 +268384,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -277287,8 +268407,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -277313,13 +268432,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -277334,8 +268451,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -277370,13 +268486,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1) \n Builder illtyped",
+              "goal_text": "std.assert-ok!\n (coq.typecheck (global (const «Builders_18.HB_unnamed_factory_22»)) X231^1) \n Builder illtyped",
               "goal_id": 1743
             },
             "cut_branch": {
-              "rule_text":
-                "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
+              "rule_text": "(std.assert-ok! _ A0) :- (std.fatal-error-w-data A0 no diagnostic returned).",
               "rule_loc": [
                 "File",
                 {
@@ -277400,8 +268514,7 @@
       "Inference",
       {
         "current_goal_id": 1748,
-        "current_goal_text":
-          "ok = ok ; ok = error X235^1 , std.fatal-error-w-data Builder illtyped X235^1",
+        "current_goal_text": "ok = ok ; ok = error X235^1 , std.fatal-error-w-data Builder illtyped X235^1",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -277453,8 +268566,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -277492,13 +268604,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -277513,8 +268623,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -277533,8 +268642,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -277629,13 +268737,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -277727,13 +268833,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -277748,13 +268852,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -277769,13 +268871,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -277790,13 +268890,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -277868,13 +268966,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -277965,13 +269061,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -278005,13 +269099,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -278045,13 +269137,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -278066,13 +269156,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -278372,13 +269460,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -278397,8 +269483,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -278423,13 +269508,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -278444,8 +269527,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -278520,8 +269602,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (A2 = ok ; A2 = error A3 , std.fatal-error-w-data A1 A3), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -278559,13 +269640,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -278580,8 +269659,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -278600,8 +269678,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -278696,13 +269773,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -278794,13 +269869,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -278815,13 +269888,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -278836,13 +269907,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -278857,13 +269926,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -278935,13 +270002,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -279032,13 +270097,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -279072,13 +270135,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -279112,13 +270173,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -279133,13 +270192,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -279439,13 +270496,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -279464,8 +270519,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -279490,13 +270544,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -279511,8 +270563,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -279547,8 +270598,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "X234^1 = ok ;\n X234^1 = error X235^1 , std.fatal-error-w-data Builder illtyped X235^1",
+              "goal_text": "X234^1 = ok ;\n X234^1 = error X235^1 , std.fatal-error-w-data Builder illtyped X235^1",
               "goal_id": 1748
             },
             "cut_branch": {
@@ -279582,8 +270632,7 @@
       "Inference",
       {
         "current_goal_id": 1745,
-        "current_goal_text":
-          "std.do!\n [(coq.subst-prod [] \n    (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n      prod `fresh_name_19` \n       (app [global (const «IsSelfA'.phant_axioms»), c1]) c2 \\\n       app\n        [global (indt «HasB.axioms_»), \n         app\n          [global\n            (const\n              «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n           c1, c2], c1]) X232^1 , coq.subst-prod [c0] X232^1 X233^1), \n  std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+        "current_goal_text": "std.do!\n [(coq.subst-prod [] \n    (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n      prod `fresh_name_19` \n       (app [global (const «IsSelfA'.phant_axioms»), c1]) c2 \\\n       app\n        [global (indt «HasB.axioms_»), \n         app\n          [global\n            (const\n              «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n           c1, c2], c1]) X232^1 , coq.subst-prod [c0] X232^1 X233^1), \n  std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -279592,8 +270641,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -279618,14 +270666,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1 , coq.subst-prod [c0] X232^1 X233^1",
+                "goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1 , coq.subst-prod [c0] X232^1 X233^1",
                 "goal_id": 1753
               },
               { "goal_text": "!", "goal_id": 1754 },
               {
-                "goal_text":
-                  "std.do!\n [std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+                "goal_text": "std.do!\n [std.assert! (extract-conclusion-params c0 X233^1 X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
                 "goal_id": 1755
               }
             ],
@@ -279676,13 +270722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -279697,8 +270741,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -279717,8 +270760,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -279813,13 +270855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -279911,13 +270951,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -279932,13 +270970,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -279953,13 +270989,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -279974,13 +271008,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -280052,13 +271084,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -280149,13 +271179,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -280189,13 +271217,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -280229,13 +271255,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -280250,13 +271274,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -280556,13 +271578,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -280581,8 +271601,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -280607,13 +271626,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -280628,8 +271645,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -280661,8 +271677,7 @@
       "Inference",
       {
         "current_goal_id": 1753,
-        "current_goal_text":
-          "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1 , coq.subst-prod [c0] X232^1 X233^1",
+        "current_goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1 , coq.subst-prod [c0] X232^1 X233^1",
         "current_goal_predicate": ",",
         "failed_attempts": [],
         "successful_attempts": [
@@ -280673,8 +271688,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1",
+                "goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1",
                 "goal_id": 1756
               },
               {
@@ -280734,13 +271748,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -280755,8 +271767,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -280775,8 +271786,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -280871,13 +271881,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -280969,13 +271977,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -280990,13 +271996,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -281011,13 +272015,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -281032,13 +272034,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -281110,13 +272110,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -281207,13 +272205,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -281247,13 +272243,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -281287,13 +272281,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -281308,13 +272300,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -281614,13 +272604,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -281639,8 +272627,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -281665,13 +272652,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -281686,8 +272671,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -281719,8 +272703,7 @@
       "Inference",
       {
         "current_goal_id": 1756,
-        "current_goal_text":
-          "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1",
+        "current_goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1",
         "current_goal_predicate": "coq.subst-prod",
         "failed_attempts": [],
         "successful_attempts": [
@@ -281824,13 +272807,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -281845,8 +272826,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -281865,8 +272845,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -281961,13 +272940,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -282059,13 +273036,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -282080,13 +273055,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -282101,13 +273074,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -282122,13 +273093,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -282200,13 +273169,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -282297,13 +273264,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -282337,13 +273302,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -282377,13 +273340,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -282398,13 +273359,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -282704,13 +273663,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -282729,8 +273686,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -282755,13 +273711,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -282776,8 +273730,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -282812,13 +273765,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1",
+              "goal_text": "coq.subst-prod [] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X232^1",
               "goal_id": 1756
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
+              "rule_text": "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
               "rule_loc": [
                 "File",
                 {
@@ -282842,8 +273793,7 @@
       "Inference",
       {
         "current_goal_id": 1757,
-        "current_goal_text":
-          "coq.subst-prod [c0] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X233^1",
+        "current_goal_text": "coq.subst-prod [c0] \n (prod `T` (sort (typ «interleave_context.396»)) c1 \\\n   prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c1]) \n    c2 \\\n    app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c1, c2], c1]) X233^1",
         "current_goal_predicate": "coq.subst-prod",
         "failed_attempts": [],
         "successful_attempts": [
@@ -282852,8 +273802,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
+                  "rule_text": "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
                   "rule_loc": [
                     "File",
                     {
@@ -282878,8 +273827,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1759 },
               {
-                "goal_text":
-                  "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X233^1",
+                "goal_text": "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X233^1",
                 "goal_id": 1760
               }
             ],
@@ -282892,8 +273840,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
+                "rule_text": "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -282955,13 +273902,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -282976,8 +273921,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -282996,8 +273940,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -283092,13 +274035,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -283190,13 +274131,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -283211,13 +274150,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -283232,13 +274169,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -283253,13 +274188,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -283331,13 +274264,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -283428,13 +274359,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -283468,13 +274397,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -283508,13 +274435,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -283529,13 +274454,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -283835,13 +274758,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -283860,8 +274781,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -283886,13 +274806,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -283907,8 +274825,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -283947,8 +274864,7 @@
               "goal_id": 1757
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
+              "rule_text": "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
               "rule_loc": [
                 "File",
                 {
@@ -283966,8 +274882,7 @@
               "goal_id": 1757
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.subst-prod [_ | _] A0 _) :- (!), \n (std.fatal-error-w-data subst-prod: not a product A0).",
+              "rule_text": "(coq.subst-prod [_ | _] A0 _) :- (!), \n (std.fatal-error-w-data subst-prod: not a product A0).",
               "rule_loc": [
                 "File",
                 {
@@ -283991,8 +274906,7 @@
       "Inference",
       {
         "current_goal_id": 1760,
-        "current_goal_text":
-          "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X233^1",
+        "current_goal_text": "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X233^1",
         "current_goal_predicate": "coq.subst-prod",
         "failed_attempts": [],
         "successful_attempts": [
@@ -284053,8 +274967,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
+                "rule_text": "(coq.subst-prod [A0 | A1] (prod _ _ A2) A3) :- (!), \n (coq.subst-prod A1 (A2 A0) A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -284116,13 +275029,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -284137,8 +275048,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -284157,8 +275067,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -284253,13 +275162,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -284351,13 +275258,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -284372,13 +275277,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -284393,13 +275296,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -284414,13 +275315,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -284492,13 +275391,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -284589,13 +275486,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -284629,13 +275524,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -284669,13 +275562,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -284690,13 +275581,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -284996,13 +275885,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -285021,8 +275908,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -285047,13 +275933,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -285068,8 +275952,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -285104,13 +275987,11 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X233^1",
+              "goal_text": "coq.subst-prod [] \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X233^1",
               "goal_id": 1760
             },
             "cut_branch": {
-              "rule_text":
-                "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
+              "rule_text": "(coq.subst-prod A0 (let _ _ A1 A2) A3) :- (!), \n (coq.subst-prod A0 (A2 A1) A3).",
               "rule_loc": [
                 "File",
                 {
@@ -285140,8 +276021,7 @@
       "Inference",
       {
         "current_goal_id": 1755,
-        "current_goal_text":
-          "std.do!\n [std.assert!\n   (extract-conclusion-params c0 \n     (prod `fresh_name_19` \n       (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n       app\n        [global (indt «HasB.axioms_»), \n         app\n          [global\n            (const\n              «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n           c0, c1], c0]) X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
+        "current_goal_text": "std.do!\n [std.assert!\n   (extract-conclusion-params c0 \n     (prod `fresh_name_19` \n       (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n       app\n        [global (indt «HasB.axioms_»), \n         app\n          [global\n            (const\n              «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n           c0, c1], c0]) X230^1) \n   The conclusion of a builder is a mixin whose parameters depend on other mixins]",
         "current_goal_predicate": "std.do!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -285150,8 +276030,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
+                  "rule_text": "(std.do! [A0 | A1]) :- A0, (!), (std.do! A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -285173,8 +276052,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "std.assert!\n (extract-conclusion-params c0 \n   (prod `fresh_name_19` \n     (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n     app\n      [global (indt «HasB.axioms_»), \n       app\n        [global\n          (const\n            «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n         c0, c1], c0]) X230^1) \n The conclusion of a builder is a mixin whose parameters depend on other mixins",
+                "goal_text": "std.assert!\n (extract-conclusion-params c0 \n   (prod `fresh_name_19` \n     (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n     app\n      [global (indt «HasB.axioms_»), \n       app\n        [global\n          (const\n            «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n         c0, c1], c0]) X230^1) \n The conclusion of a builder is a mixin whose parameters depend on other mixins",
                 "goal_id": 1762
               },
               { "goal_text": "!", "goal_id": 1763 },
@@ -285246,13 +276124,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -285267,8 +276143,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -285287,8 +276162,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -285383,13 +276257,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -285481,13 +276353,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -285502,13 +276372,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -285523,13 +276391,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -285544,13 +276410,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -285622,13 +276486,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -285719,13 +276581,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -285759,13 +276619,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -285799,13 +276657,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -285820,13 +276676,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -286126,13 +276980,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -286151,8 +277003,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -286177,13 +277028,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -286198,8 +277047,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -286231,8 +277079,7 @@
       "Inference",
       {
         "current_goal_id": 1762,
-        "current_goal_text":
-          "std.assert!\n (extract-conclusion-params c0 \n   (prod `fresh_name_19` \n     (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n     app\n      [global (indt «HasB.axioms_»), \n       app\n        [global\n          (const\n            «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n         c0, c1], c0]) X230^1) \n The conclusion of a builder is a mixin whose parameters depend on other mixins",
+        "current_goal_text": "std.assert!\n (extract-conclusion-params c0 \n   (prod `fresh_name_19` \n     (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n     app\n      [global (indt «HasB.axioms_»), \n       app\n        [global\n          (const\n            «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n         c0, c1], c0]) X230^1) \n The conclusion of a builder is a mixin whose parameters depend on other mixins",
         "current_goal_predicate": "std.assert!",
         "failed_attempts": [],
         "successful_attempts": [
@@ -286241,8 +277088,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                  "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -286267,8 +277113,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «HasB.axioms_»), \n        app\n         [global\n           (const\n             «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n          c0, c1], c0]) X230^1)",
+                "goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «HasB.axioms_»), \n        app\n         [global\n           (const\n             «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n          c0, c1], c0]) X230^1)",
                 "goal_id": 1765
               },
               { "goal_text": "!", "goal_id": 1766 }
@@ -286282,8 +277127,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -286359,13 +277203,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -286380,8 +277222,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -286400,8 +277241,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -286496,13 +277336,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -286594,13 +277432,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -286615,13 +277451,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -286636,13 +277470,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -286657,13 +277489,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -286735,13 +277565,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -286832,13 +277660,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -286872,13 +277698,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -286912,13 +277736,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -286933,13 +277755,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -287239,13 +278059,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -287264,8 +278082,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -287290,13 +278107,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -287311,8 +278126,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -287344,8 +278158,7 @@
       "Inference",
       {
         "current_goal_id": 1765,
-        "current_goal_text":
-          "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «HasB.axioms_»), \n        app\n         [global\n           (const\n             «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n          c0, c1], c0]) X230^1)",
+        "current_goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1 ;\n std.fatal-error-w-data\n  The conclusion of a builder is a mixin whose parameters depend on other mixins \n  (extract-conclusion-params c0 \n    (prod `fresh_name_19` \n      (app [global (const «IsSelfA'.phant_axioms»), c0]) c1 \\\n      app\n       [global (indt «HasB.axioms_»), \n        app\n         [global\n           (const\n             «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n          c0, c1], c0]) X230^1)",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -287375,8 +278188,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
+                "goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
                 "goal_id": 1767
               }
             ],
@@ -287408,8 +278220,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -287485,13 +278296,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -287506,8 +278315,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -287526,8 +278334,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -287622,13 +278429,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -287720,13 +278525,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -287741,13 +278544,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -287762,13 +278563,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -287783,13 +278582,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -287861,13 +278658,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -287958,13 +278753,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -287998,13 +278791,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -288038,13 +278829,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -288059,13 +278848,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -288365,13 +279152,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -288390,8 +279175,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -288416,13 +279200,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -288437,8 +279219,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -288470,8 +279251,7 @@
       "Inference",
       {
         "current_goal_id": 1767,
-        "current_goal_text":
-          "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
+        "current_goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
         "current_goal_predicate": "extract-conclusion-params",
         "failed_attempts": [],
         "successful_attempts": [
@@ -288480,13 +279260,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                  "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 115,
                       "column": 0,
                       "character": 3974
@@ -288510,8 +279288,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1768 },
               {
-                "goal_text":
-                  "pi c1 \\\n decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n  extract-conclusion-params c0 \n   (app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c0, c1], c0]) X230^1",
+                "goal_text": "pi c1 \\\n decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n  extract-conclusion-params c0 \n   (app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c0, c1], c0]) X230^1",
                 "goal_id": 1769
               }
             ],
@@ -288524,13 +279301,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -288564,8 +279339,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -288641,13 +279415,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -288662,8 +279434,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -288682,8 +279453,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -288778,13 +279548,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -288876,13 +279644,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -288897,13 +279663,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -288918,13 +279682,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -288939,13 +279701,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -289017,13 +279777,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -289114,13 +279872,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -289154,13 +279910,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -289194,13 +279948,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -289215,13 +279967,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -289521,13 +280271,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -289546,8 +280294,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -289572,13 +280319,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -289593,8 +280338,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -289629,18 +280373,15 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
+              "goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
               "goal_id": 1767
             },
             "cut_branch": {
-              "rule_text":
-                "(extract-conclusion-params A0 (app [global A1 | A2]) A3) :- (!), \n (factory-alias->gref A1 A4), (factory-nparams A4 A5), \n (std.map A2 (copy-pack-holes A0) A6), (std.spy (std.take A5 A6 A3)).",
+              "rule_text": "(extract-conclusion-params A0 (app [global A1 | A2]) A3) :- (!), \n (factory-alias->gref A1 A4), (factory-nparams A4 A5), \n (std.map A2 (copy-pack-holes A0) A6), (std.spy (std.take A5 A6 A3)).",
               "rule_loc": [
                 "File",
                 {
-                  "filename":
-                    "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                  "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                   "line": 117,
                   "column": 0,
                   "character": 4090
@@ -289650,18 +280391,15 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
+              "goal_text": "extract-conclusion-params c0 \n (prod `fresh_name_19` (app [global (const «IsSelfA'.phant_axioms»), c0]) \n   c1 \\\n   app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
               "goal_id": 1767
             },
             "cut_branch": {
-              "rule_text":
-                "(extract-conclusion-params A0 A1 A2) :- (whd1 A1 A3), (!), \n (extract-conclusion-params A0 A3 A2).",
+              "rule_text": "(extract-conclusion-params A0 A1 A2) :- (whd1 A1 A3), (!), \n (extract-conclusion-params A0 A3 A2).",
               "rule_loc": [
                 "File",
                 {
-                  "filename":
-                    "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                  "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                   "line": 122,
                   "column": 0,
                   "character": 4303
@@ -289681,8 +280419,7 @@
       "Inference",
       {
         "current_goal_id": 1769,
-        "current_goal_text":
-          "pi c1 \\\n decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n  extract-conclusion-params c0 \n   (app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c0, c1], c0]) X230^1",
+        "current_goal_text": "pi c1 \\\n decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n  extract-conclusion-params c0 \n   (app\n     [global (indt «HasB.axioms_»), \n      app\n       [global\n         (const\n           «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n        c0, c1], c0]) X230^1",
         "current_goal_predicate": "pi",
         "failed_attempts": [],
         "successful_attempts": [
@@ -289693,8 +280430,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n extract-conclusion-params c0 \n  (app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
+                "goal_text": "decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n extract-conclusion-params c0 \n  (app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
                 "goal_id": 1770
               }
             ],
@@ -289712,13 +280448,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -289752,8 +280486,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -289829,13 +280562,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -289850,8 +280581,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -289870,8 +280600,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -289966,13 +280695,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -290064,13 +280791,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -290085,13 +280810,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -290106,13 +280829,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -290127,13 +280848,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -290205,13 +280924,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -290302,13 +281019,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -290342,13 +281057,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -290382,13 +281095,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -290403,13 +281114,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -290709,13 +281418,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -290734,8 +281441,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -290760,13 +281466,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -290781,8 +281485,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -290814,8 +281517,7 @@
       "Inference",
       {
         "current_goal_id": 1770,
-        "current_goal_text":
-          "decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n extract-conclusion-params c0 \n  (app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
+        "current_goal_text": "decl c1 _ (app [global (const «IsSelfA'.phant_axioms»), c0]) =>\n extract-conclusion-params c0 \n  (app\n    [global (indt «HasB.axioms_»), \n     app\n      [global\n        (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n       c0, c1], c0]) X230^1",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -290826,8 +281528,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "extract-conclusion-params c0 \n (app\n   [global (indt «HasB.axioms_»), \n    app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0]) X230^1",
+                "goal_text": "extract-conclusion-params c0 \n (app\n   [global (indt «HasB.axioms_»), \n    app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0]) X230^1",
                 "goal_id": 1771
               }
             ],
@@ -290850,13 +281551,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -290890,8 +281589,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -290967,13 +281665,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -290988,8 +281684,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -291008,8 +281703,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -291104,13 +281798,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -291202,13 +281894,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -291223,13 +281913,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -291244,13 +281932,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -291265,13 +281951,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -291343,13 +282027,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -291440,13 +282122,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -291480,13 +282160,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -291520,13 +282198,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -291541,13 +282217,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -291847,13 +282521,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -291872,8 +282544,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -291898,13 +282569,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -291919,8 +282588,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -291952,21 +282620,18 @@
       "Inference",
       {
         "current_goal_id": 1771,
-        "current_goal_text":
-          "extract-conclusion-params c0 \n (app\n   [global (indt «HasB.axioms_»), \n    app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0]) X230^1",
+        "current_goal_text": "extract-conclusion-params c0 \n (app\n   [global (indt «HasB.axioms_»), \n    app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0]) X230^1",
         "current_goal_predicate": "extract-conclusion-params",
         "failed_attempts": [
           {
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (app [global A1 | A2]) A3) :- (!), \n (factory-alias->gref A1 A4), (factory-nparams A4 A5), \n (std.map A2 (copy-pack-holes A0) A6), (std.spy (std.take A5 A6 A3)).",
+                "rule_text": "(extract-conclusion-params A0 (app [global A1 | A2]) A3) :- (!), \n (factory-alias->gref A1 A4), (factory-nparams A4 A5), \n (std.map A2 (copy-pack-holes A0) A6), (std.spy (std.take A5 A6 A3)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 117,
                     "column": 0,
                     "character": 4090
@@ -291991,13 +282656,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                  "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 115,
                       "column": 0,
                       "character": 3974
@@ -292016,8 +282679,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1772 },
               {
-                "goal_text":
-                  "factory-alias->gref (indt «HasB.axioms_») X236^2",
+                "goal_text": "factory-alias->gref (indt «HasB.axioms_») X236^2",
                 "goal_id": 1773
               },
               {
@@ -292025,8 +282687,7 @@
                 "goal_id": 1774
               },
               {
-                "goal_text":
-                  "std.map\n [app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1], c0] (copy-pack-holes c0) X238^2",
+                "goal_text": "std.map\n [app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1], c0] (copy-pack-holes c0) X238^2",
                 "goal_id": 1775
               },
               {
@@ -292043,13 +282704,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -292074,13 +282733,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -292114,8 +282771,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -292191,13 +282847,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -292212,8 +282866,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -292232,8 +282885,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -292328,13 +282980,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -292426,13 +283076,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -292447,13 +283095,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -292468,13 +283114,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -292489,13 +283133,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -292567,13 +283209,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -292664,13 +283304,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -292704,13 +283342,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -292744,13 +283380,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -292765,13 +283399,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -293071,13 +283703,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -293096,8 +283726,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -293122,13 +283751,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -293143,8 +283770,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -293179,18 +283805,15 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "extract-conclusion-params c0 \n (app\n   [global (indt «HasB.axioms_»), \n    app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0]) X230^1",
+              "goal_text": "extract-conclusion-params c0 \n (app\n   [global (indt «HasB.axioms_»), \n    app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0]) X230^1",
               "goal_id": 1771
             },
             "cut_branch": {
-              "rule_text":
-                "(extract-conclusion-params A0 A1 A2) :- (whd1 A1 A3), (!), \n (extract-conclusion-params A0 A3 A2).",
+              "rule_text": "(extract-conclusion-params A0 A1 A2) :- (whd1 A1 A3), (!), \n (extract-conclusion-params A0 A3 A2).",
               "rule_loc": [
                 "File",
                 {
-                  "filename":
-                    "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                  "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                   "line": 122,
                   "column": 0,
                   "character": 4303
@@ -293210,8 +283833,7 @@
       "Inference",
       {
         "current_goal_id": 1773,
-        "current_goal_text":
-          "factory-alias->gref (indt «HasB.axioms_») X236^2",
+        "current_goal_text": "factory-alias->gref (indt «HasB.axioms_») X236^2",
         "current_goal_predicate": "factory-alias->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -293220,13 +283842,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                  "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 74,
                       "column": 0,
                       "character": 2385
@@ -293255,13 +283875,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 74,
                     "column": 0,
                     "character": 2385
@@ -293276,13 +283894,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -293307,13 +283923,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -293347,8 +283961,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -293424,13 +284037,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -293445,8 +284056,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -293465,8 +284075,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -293561,13 +284170,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -293659,13 +284266,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -293680,13 +284285,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -293701,13 +284304,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -293722,13 +284323,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -293800,13 +284399,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -293897,13 +284494,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -293937,13 +284532,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -293977,13 +284570,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -293998,13 +284589,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -294304,13 +284893,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -294329,8 +284916,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -294355,13 +284941,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -294376,8 +284960,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -294416,8 +284999,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -294441,8 +285023,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasA.Axioms_») (const «HasA.phant_Build») \n  «interleave_context.HasA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -294466,8 +285047,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -294491,8 +285071,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «HasB.Axioms_») (const «HasB.phant_Build») \n  «interleave_context.HasB.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -294516,8 +285095,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -294541,8 +285119,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA.Axioms_») (const «IsSelfA.phant_Build») \n  «interleave_context.IsSelfA.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -294566,8 +285143,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -294591,8 +285167,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
+                "rule_text": "(phant-abbrev (indc «IsSelfA'.Axioms_») (const «IsSelfA'.phant_Build») \n  «interleave_context.IsSelfA'.Build») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -294620,8 +285195,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -294640,13 +285214,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
+                "rule_text": "(factory-alias->gref A0 A1) :- (phant-abbrev A1 A0 _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 74,
                     "column": 0,
                     "character": 2385
@@ -294661,13 +285233,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -294692,13 +285262,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -294732,8 +285300,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -294809,13 +285376,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -294830,8 +285395,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -294850,8 +285414,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -294946,13 +285509,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -295044,13 +285605,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -295065,13 +285624,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -295086,13 +285643,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -295107,13 +285662,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -295185,13 +285738,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -295282,13 +285833,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -295322,13 +285871,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -295362,13 +285909,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -295383,13 +285928,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -295689,13 +286232,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -295714,8 +286255,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -295740,13 +286280,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -295761,8 +286299,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -295794,8 +286331,7 @@
       "Inference",
       {
         "current_goal_id": 1773,
-        "current_goal_text":
-          "factory-alias->gref (indt «HasB.axioms_») X236^2",
+        "current_goal_text": "factory-alias->gref (indt «HasB.axioms_») X236^2",
         "current_goal_predicate": "factory-alias->gref",
         "failed_attempts": [],
         "successful_attempts": [
@@ -295804,13 +286340,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                  "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 75,
                       "column": 0,
                       "character": 2443
@@ -295839,13 +286373,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2443
@@ -295860,13 +286392,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -295891,13 +286421,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -295931,8 +286459,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -296008,13 +286535,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -296029,8 +286554,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -296049,8 +286573,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -296145,13 +286668,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -296243,13 +286764,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -296264,13 +286783,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -296285,13 +286802,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -296306,13 +286821,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -296384,13 +286897,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -296481,13 +286992,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -296521,13 +287030,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -296561,13 +287068,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -296582,13 +287087,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -296888,13 +287391,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -296913,8 +287414,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -296939,13 +287439,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -296960,8 +287458,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -297000,8 +287497,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasB.axioms_») (const «HasB.phant_axioms») \n  «interleave_context.HasB.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -297022,8 +287518,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                  "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                   "rule_loc": [
                     "File",
                     {
@@ -297052,8 +287547,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
+                "rule_text": "(phant-abbrev (indt «HasA.axioms_») (const «HasA.phant_axioms») \n  «interleave_context.HasA.axioms») :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -297072,13 +287566,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
+                "rule_text": "(factory-alias->gref A0 A0) :- (phant-abbrev A0 _ _), (!).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 75,
                     "column": 0,
                     "character": 2443
@@ -297093,13 +287585,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -297124,13 +287614,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -297164,8 +287652,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -297241,13 +287728,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -297262,8 +287747,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -297282,8 +287766,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -297378,13 +287861,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -297476,13 +287957,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -297497,13 +287976,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -297518,13 +287995,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -297539,13 +288014,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -297617,13 +288090,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -297714,13 +288185,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -297754,13 +288223,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -297794,13 +288261,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -297815,13 +288280,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -298121,13 +288584,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -298146,8 +288607,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -298172,13 +288632,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -298193,8 +288651,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -298233,8 +288690,7 @@
               "goal_id": 1779
             },
             "cut_branch": {
-              "rule_text":
-                "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
+              "rule_text": "(phant-abbrev (indt «IsSelfA.axioms_») (const «IsSelfA.phant_axioms») \n  «interleave_context.IsSelfA.axioms») :- .",
               "rule_loc": [
                 "File",
                 {
@@ -298252,8 +288708,7 @@
               "goal_id": 1779
             },
             "cut_branch": {
-              "rule_text":
-                "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
+              "rule_text": "(phant-abbrev (indt «IsSelfA'.axioms_») (const «IsSelfA'.phant_axioms») \n  «interleave_context.IsSelfA'.axioms») :- .",
               "rule_loc": [
                 "File",
                 {
@@ -298267,13 +288722,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «HasB.axioms_») X236^2",
+              "goal_text": "factory-alias->gref (indt «HasB.axioms_») X236^2",
               "goal_id": 1773
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «A.axioms_») (indt «A.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «A.axioms_») (indt «A.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -298287,13 +288740,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «HasB.axioms_») X236^2",
+              "goal_text": "factory-alias->gref (indt «HasB.axioms_») X236^2",
               "goal_id": 1773
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «B.axioms_») (indt «B.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «B.axioms_») (indt «B.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -298307,13 +288758,11 @@
           },
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "factory-alias->gref (indt «HasB.axioms_») X236^2",
+              "goal_text": "factory-alias->gref (indt «HasB.axioms_») X236^2",
               "goal_id": 1773
             },
             "cut_branch": {
-              "rule_text":
-                "(factory-alias->gref (indt «SelfA.axioms_») (indt «SelfA.axioms_»)) :- .",
+              "rule_text": "(factory-alias->gref (indt «SelfA.axioms_») (indt «SelfA.axioms_»)) :- .",
               "rule_loc": [
                 "File",
                 {
@@ -298366,8 +288815,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «HasB.axioms_») 1) :- .",
+                "rule_text": "(factory-nparams (indt «HasB.axioms_») 1) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -298388,8 +288836,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(factory-nparams (indt «HasA.axioms_») 1) :- .",
+                  "rule_text": "(factory-nparams (indt «HasA.axioms_») 1) :- .",
                   "rule_loc": [
                     "File",
                     {
@@ -298418,8 +288865,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-nparams (indt «HasA.axioms_») 1) :- .",
+                "rule_text": "(factory-nparams (indt «HasA.axioms_») 1) :- .",
                 "rule_loc": [
                   "File",
                   {
@@ -298438,13 +288884,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -298469,13 +288913,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -298509,8 +288951,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -298586,13 +289027,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -298607,8 +289046,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -298627,8 +289065,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -298723,13 +289160,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -298821,13 +289256,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -298842,13 +289275,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -298863,13 +289294,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -298884,13 +289313,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -298962,13 +289389,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -299059,13 +289484,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -299099,13 +289522,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -299139,13 +289560,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -299160,13 +289579,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -299466,13 +289883,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -299491,8 +289906,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -299517,13 +289931,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -299538,8 +289950,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -299571,8 +289982,7 @@
       "Inference",
       {
         "current_goal_id": 1775,
-        "current_goal_text":
-          "std.map\n [app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1], c0] (copy-pack-holes c0) X238^2",
+        "current_goal_text": "std.map\n [app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1], c0] (copy-pack-holes c0) X238^2",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -299581,8 +289991,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -299606,8 +290015,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "copy-pack-holes c0 \n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
+                "goal_text": "copy-pack-holes c0 \n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
                 "goal_id": 1781
               },
               {
@@ -299624,8 +290032,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -299644,13 +290051,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -299675,13 +290080,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -299715,8 +290118,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -299792,13 +290194,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -299813,8 +290213,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -299833,8 +290232,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -299929,13 +290327,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -300027,13 +290423,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -300048,13 +290442,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -300069,13 +290461,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -300090,13 +290480,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -300168,13 +290556,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -300265,13 +290651,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -300305,13 +290689,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -300345,13 +290727,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -300366,13 +290746,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -300672,13 +291050,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -300697,8 +291073,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -300723,13 +291098,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -300744,8 +291117,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -300777,8 +291149,7 @@
       "Inference",
       {
         "current_goal_id": 1781,
-        "current_goal_text":
-          "copy-pack-holes c0 \n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
+        "current_goal_text": "copy-pack-holes c0 \n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
         "current_goal_predicate": "copy-pack-holes",
         "failed_attempts": [],
         "successful_attempts": [
@@ -300787,13 +291158,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                  "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 318,
                       "column": 0,
                       "character": 12866
@@ -300820,8 +291189,7 @@
                 "goal_id": 1784
               },
               {
-                "goal_text":
-                  "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X243^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X243^2 | c6] c3) | X242^2]\n =>\n copy\n  (app\n    [global\n      (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n     c0, c1]) X239^2",
+                "goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X243^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X243^2 | c6] c3) | X242^2]\n =>\n copy\n  (app\n    [global\n      (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n     c0, c1]) X239^2",
                 "goal_id": 1785
               }
             ],
@@ -300834,13 +291202,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -300855,8 +291221,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -300875,13 +291240,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -300906,13 +291269,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -300946,8 +291307,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -301023,13 +291383,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -301044,8 +291402,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -301064,8 +291421,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -301160,13 +291516,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -301258,13 +291612,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -301279,13 +291631,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -301300,13 +291650,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -301321,13 +291669,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -301399,13 +291745,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -301496,13 +291840,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -301536,13 +291878,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -301576,13 +291916,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -301597,13 +291935,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -301903,13 +292239,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -301928,8 +292262,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -301954,13 +292287,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -301975,8 +292306,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -302017,13 +292347,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                  "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 200,
                       "column": 0,
                       "character": 7260
@@ -302052,13 +292380,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -302073,13 +292399,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -302094,8 +292418,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -302114,13 +292437,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -302145,13 +292466,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -302185,8 +292504,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -302262,13 +292580,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -302283,8 +292599,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -302303,8 +292618,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -302399,13 +292713,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -302497,13 +292809,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -302518,13 +292828,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -302539,13 +292847,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -302560,13 +292866,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -302638,13 +292942,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -302735,13 +293037,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -302775,13 +293075,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -302815,13 +293113,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -302836,13 +293132,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -303142,13 +293436,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -303167,8 +293459,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -303193,13 +293484,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -303214,8 +293503,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -303256,8 +293544,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                  "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -303276,8 +293563,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "findall_solutions (local-canonical X244^2) X245^2",
+                "goal_text": "findall_solutions (local-canonical X244^2) X245^2",
                 "goal_id": 1788
               }
             ],
@@ -303290,8 +293576,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -303310,13 +293595,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -303331,13 +293614,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -303352,8 +293633,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -303372,13 +293652,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -303403,13 +293681,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -303443,8 +293719,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -303520,13 +293795,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -303541,8 +293814,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -303561,8 +293833,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -303657,13 +293928,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -303755,13 +294024,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -303776,13 +294043,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -303797,13 +294062,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -303818,13 +294081,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -303896,13 +294157,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -303993,13 +294252,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -304033,13 +294290,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -304073,13 +294328,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -304094,13 +294347,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -304400,13 +294651,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -304425,8 +294674,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -304451,13 +294699,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -304472,8 +294718,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -304505,8 +294750,7 @@
       "Findall",
       {
         "findall_goal_id": 1788,
-        "findall_goal_text":
-          "findall_solutions (local-canonical X244^2) X245^2",
+        "findall_goal_text": "findall_solutions (local-canonical X244^2) X245^2",
         "findall_cards": [
           {
             "step_id": 0,
@@ -304546,8 +294790,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -304566,13 +294809,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -304587,13 +294828,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -304608,8 +294847,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -304628,13 +294866,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -304659,13 +294895,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -304699,8 +294933,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -304776,13 +295009,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -304797,8 +295028,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -304817,8 +295047,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -304913,13 +295142,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -305011,13 +295238,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -305032,13 +295257,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -305053,13 +295276,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -305074,13 +295295,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -305152,13 +295371,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -305249,13 +295466,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -305289,13 +295504,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -305329,13 +295542,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -305350,13 +295561,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -305656,13 +295865,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -305681,8 +295888,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -305707,13 +295913,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -305728,8 +295932,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -305813,13 +296016,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -305834,13 +296035,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -305855,8 +296054,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -305875,13 +296073,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -305906,13 +296102,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -305946,8 +296140,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -306023,13 +296216,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -306044,8 +296235,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -306064,8 +296254,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -306160,13 +296349,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -306258,13 +296445,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -306279,13 +296464,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -306300,13 +296483,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -306321,13 +296502,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -306399,13 +296578,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -306496,13 +296673,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -306536,13 +296711,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -306576,13 +296749,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -306597,13 +296768,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -306903,13 +297072,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -306928,8 +297095,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -306954,13 +297120,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -306975,8 +297139,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -307021,8 +297184,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                       "line": 196,
                       "column": 0,
                       "character": 7411
@@ -307046,8 +297208,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 7411
@@ -307062,13 +297223,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -307083,8 +297242,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -307103,13 +297261,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -307134,13 +297290,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -307174,8 +297328,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -307251,13 +297404,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -307272,8 +297423,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -307292,8 +297442,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -307388,13 +297537,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -307486,13 +297633,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -307507,13 +297652,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -307528,13 +297671,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -307549,13 +297690,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -307627,13 +297766,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -307724,13 +297861,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -307764,13 +297899,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -307804,13 +297937,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -307825,13 +297956,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -308131,13 +298260,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -308156,8 +298283,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -308182,13 +298308,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -308203,8 +298327,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -308236,8 +298359,7 @@
       "Inference",
       {
         "current_goal_id": 1785,
-        "current_goal_text":
-          "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X243^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X243^2 | c6] c3)] =>\n copy\n  (app\n    [global\n      (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n     c0, c1]) X239^2",
+        "current_goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X243^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X243^2 | c6] c3)] =>\n copy\n  (app\n    [global\n      (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n     c0, c1]) X239^2",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -308248,8 +298370,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "copy\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
+                "goal_text": "copy\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
                 "goal_id": 1791
               }
             ],
@@ -308267,13 +298388,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -308288,8 +298407,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -308308,13 +298426,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -308339,13 +298455,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -308379,8 +298493,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -308456,13 +298569,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -308477,8 +298588,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -308497,8 +298607,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -308593,13 +298702,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -308691,13 +298798,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -308712,13 +298817,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -308733,13 +298836,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -308754,13 +298855,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -308832,13 +298931,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -308929,13 +299026,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -308969,13 +299064,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -309009,13 +299102,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -309030,13 +299121,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -309336,13 +299425,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -309361,8 +299448,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -309387,13 +299473,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -309408,8 +299492,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -309441,8 +299524,7 @@
       "Inference",
       {
         "current_goal_id": 1791,
-        "current_goal_text":
-          "copy\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
+        "current_goal_text": "copy\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -309451,8 +299533,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X243^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X243^2 | A4] A1).",
+                  "rule_text": "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X243^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X243^2 | A4] A1).",
                   "rule_loc": [ "Context", 577 ]
                 }
               ],
@@ -309470,8 +299551,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "pack? (const «Builders_18.Builders_18_T__canonical__interleave_context_A») \n _",
+                "goal_text": "pack? (const «Builders_18.Builders_18_T__canonical__interleave_context_A») \n _",
                 "goal_id": 1792
               },
               { "goal_text": "!", "goal_id": 1793 },
@@ -309482,8 +299562,7 @@
               { "goal_text": "copy c0 X243^2", "goal_id": 1795 },
               { "goal_text": "std.map X248^2 copy X249^2", "goal_id": 1796 },
               {
-                "goal_text":
-                  "std.rev [global (const «elpi.hole»), X243^2 | X249^2] X246^2",
+                "goal_text": "std.rev [global (const «elpi.hole»), X243^2 | X249^2] X246^2",
                 "goal_id": 1797
               }
             ],
@@ -309496,8 +299575,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X243^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X243^2 | A4] A1).",
+                "rule_text": "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X243^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X243^2 | A4] A1).",
                 "rule_loc": [ "Context", 577 ]
               }
             ],
@@ -309513,13 +299591,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -309534,8 +299610,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -309554,13 +299629,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -309585,13 +299658,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -309625,8 +299696,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -309702,13 +299772,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -309723,8 +299791,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -309743,8 +299810,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -309839,13 +299905,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -309937,13 +300001,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -309958,13 +300020,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -309979,13 +300039,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -310000,13 +300058,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -310078,13 +300134,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -310175,13 +300229,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -310215,13 +300267,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -310255,13 +300305,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -310276,13 +300324,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -310582,13 +300628,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -310607,8 +300651,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -310633,13 +300676,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -310654,8 +300695,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -310687,8 +300727,7 @@
       "Inference",
       {
         "current_goal_id": 1792,
-        "current_goal_text":
-          "pack? (const «Builders_18.Builders_18_T__canonical__interleave_context_A») \n _",
+        "current_goal_text": "pack? (const «Builders_18.Builders_18_T__canonical__interleave_context_A») \n _",
         "current_goal_predicate": "pack?",
         "failed_attempts": [],
         "successful_attempts": [],
@@ -310698,8 +300737,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X243^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X243^2 | A4] A1).",
+                "rule_text": "(copy (app [global A5 | A0]) (app [global A5 | A1])) :- (pack? A5 _), (!), \n (std.rev A0 [A2, c0 | A3]), (copy c0 X243^2), (std.map A3 copy A4), \n (std.rev [global (const «elpi.hole»), X243^2 | A4] A1).",
                 "rule_loc": [ "Context", 577 ]
               }
             ],
@@ -310715,13 +300753,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -310736,8 +300772,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -310756,13 +300791,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -310787,13 +300820,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -310827,8 +300858,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -310904,13 +300934,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -310925,8 +300953,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -310945,8 +300972,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -311041,13 +301067,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -311139,13 +301163,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -311160,13 +301182,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -311181,13 +301201,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -311202,13 +301220,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -311280,13 +301296,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -311377,13 +301391,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -311417,13 +301429,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -311457,13 +301467,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -311478,13 +301486,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -311784,13 +301790,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -311809,8 +301813,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -311835,13 +301838,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -311856,8 +301857,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -311889,8 +301889,7 @@
       "Inference",
       {
         "current_goal_id": 1791,
-        "current_goal_text":
-          "copy\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
+        "current_goal_text": "copy\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -311899,8 +301898,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -311922,14 +301920,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "name\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1])",
+                "goal_text": "name\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1])",
                 "goal_id": 1798
               },
               { "goal_text": "!", "goal_id": 1799 },
               {
-                "goal_text":
-                  "app\n [global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n  c0, c1] = X239^2",
+                "goal_text": "app\n [global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n  c0, c1] = X239^2",
                 "goal_id": 1800
               },
               { "goal_text": "!", "goal_id": 1801 }
@@ -311943,8 +301939,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -311968,13 +301963,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -311989,8 +301982,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -312009,13 +302001,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -312040,13 +302030,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -312080,8 +302068,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -312157,13 +302144,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -312178,8 +302163,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -312198,8 +302182,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -312294,13 +302277,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -312392,13 +302373,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -312413,13 +302392,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -312434,13 +302411,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -312455,13 +302430,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -312533,13 +302506,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -312630,13 +302601,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -312670,13 +302639,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -312710,13 +302677,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -312731,13 +302696,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -313037,13 +303000,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -313062,8 +303023,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -313088,13 +303048,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -313109,8 +303067,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -313142,8 +303099,7 @@
       "Inference",
       {
         "current_goal_id": 1798,
-        "current_goal_text":
-          "name\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1])",
+        "current_goal_text": "name\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1])",
         "current_goal_predicate": "name",
         "failed_attempts": [
           { "rule": [ "BuiltinRule", [ "FFI", "name" ] ], "events": [] }
@@ -313160,8 +303116,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -313185,13 +303140,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -313206,8 +303159,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -313226,13 +303178,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -313257,13 +303207,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -313297,8 +303245,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -313374,13 +303321,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -313395,8 +303340,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -313415,8 +303359,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -313511,13 +303454,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -313609,13 +303550,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -313630,13 +303569,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -313651,13 +303588,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -313672,13 +303607,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -313750,13 +303683,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -313847,13 +303778,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -313887,13 +303816,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -313927,13 +303854,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -313948,13 +303873,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -314254,13 +304177,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -314279,8 +304200,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -314305,13 +304225,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -314326,8 +304244,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -314359,8 +304276,7 @@
       "Inference",
       {
         "current_goal_id": 1791,
-        "current_goal_text":
-          "copy\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
+        "current_goal_text": "copy\n (app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1]) X239^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -314369,8 +304285,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                  "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -314393,8 +304308,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1802 },
               {
-                "goal_text":
-                  "std.map\n [global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n  c0, c1] copy X250^2",
+                "goal_text": "std.map\n [global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n  c0, c1] copy X250^2",
                 "goal_id": 1803
               }
             ],
@@ -314407,8 +304321,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -314432,13 +304345,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -314453,8 +304364,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -314473,13 +304383,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -314504,13 +304412,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -314544,8 +304450,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -314621,13 +304526,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -314642,8 +304545,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -314662,8 +304564,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -314758,13 +304659,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -314856,13 +304755,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -314877,13 +304774,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -314898,13 +304793,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -314919,13 +304812,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -314997,13 +304888,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -315094,13 +304983,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -315134,13 +305021,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -315174,13 +305059,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -315195,13 +305078,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -315501,13 +305382,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -315526,8 +305405,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -315552,13 +305430,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -315573,8 +305449,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -315612,8 +305487,7 @@
       "Inference",
       {
         "current_goal_id": 1803,
-        "current_goal_text":
-          "std.map\n [global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n  c0, c1] copy X250^2",
+        "current_goal_text": "std.map\n [global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n  c0, c1] copy X250^2",
         "current_goal_predicate": "std.map",
         "failed_attempts": [],
         "successful_attempts": [
@@ -315622,8 +305496,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -315647,8 +305520,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "copy\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»)) \n X251^2",
+                "goal_text": "copy\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»)) \n X251^2",
                 "goal_id": 1804
               },
               {
@@ -315665,8 +305537,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -315685,8 +305556,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -315710,13 +305580,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -315731,8 +305599,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -315751,13 +305618,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -315782,13 +305647,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -315822,8 +305685,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -315899,13 +305761,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -315920,8 +305780,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -315940,8 +305799,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -316036,13 +305894,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -316134,13 +305990,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -316155,13 +306009,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -316176,13 +306028,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -316197,13 +306047,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -316275,13 +306123,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -316372,13 +306218,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -316412,13 +306256,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -316452,13 +306294,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -316473,13 +306313,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -316779,13 +306617,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -316804,8 +306640,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -316830,13 +306665,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -316851,8 +306684,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -316884,8 +306716,7 @@
       "Inference",
       {
         "current_goal_id": 1804,
-        "current_goal_text":
-          "copy\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»)) \n X251^2",
+        "current_goal_text": "copy\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»)) \n X251^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -316894,8 +306725,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -316917,14 +306747,12 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "name\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»))",
+                "goal_text": "name\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»))",
                 "goal_id": 1806
               },
               { "goal_text": "!", "goal_id": 1807 },
               {
-                "goal_text":
-                  "global (const «Builders_18.Builders_18_T__canonical__interleave_context_A»)\n = X251^2",
+                "goal_text": "global (const «Builders_18.Builders_18_T__canonical__interleave_context_A»)\n = X251^2",
                 "goal_id": 1808
               },
               { "goal_text": "!", "goal_id": 1809 }
@@ -316938,8 +306766,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -316958,8 +306785,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -316978,8 +306804,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -317003,13 +306828,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -317024,8 +306847,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -317044,13 +306866,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -317075,13 +306895,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -317115,8 +306933,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -317192,13 +307009,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -317213,8 +307028,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -317233,8 +307047,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -317329,13 +307142,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -317427,13 +307238,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -317448,13 +307257,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -317469,13 +307276,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -317490,13 +307295,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -317568,13 +307371,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -317665,13 +307466,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -317705,13 +307504,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -317745,13 +307542,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -317766,13 +307561,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -318072,13 +307865,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -318097,8 +307888,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -318123,13 +307913,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -318144,8 +307932,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -318177,8 +307964,7 @@
       "Inference",
       {
         "current_goal_id": 1806,
-        "current_goal_text":
-          "name\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»))",
+        "current_goal_text": "name\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»))",
         "current_goal_predicate": "name",
         "failed_attempts": [
           { "rule": [ "BuiltinRule", [ "FFI", "name" ] ], "events": [] }
@@ -318195,8 +307981,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -318215,8 +308000,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -318235,8 +308019,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -318260,13 +308043,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -318281,8 +308062,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -318301,13 +308081,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -318332,13 +308110,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -318372,8 +308148,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -318449,13 +308224,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -318470,8 +308243,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -318490,8 +308262,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -318586,13 +308357,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -318684,13 +308453,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -318705,13 +308472,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -318726,13 +308491,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -318747,13 +308510,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -318825,13 +308586,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -318922,13 +308681,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -318962,13 +308719,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -319002,13 +308757,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -319023,13 +308776,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -319329,13 +309080,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -319354,8 +309103,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -319380,13 +309128,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -319401,8 +309147,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -319434,8 +309179,7 @@
       "Inference",
       {
         "current_goal_id": 1804,
-        "current_goal_text":
-          "copy\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»)) \n X251^2",
+        "current_goal_text": "copy\n (global\n   (const «Builders_18.Builders_18_T__canonical__interleave_context_A»)) \n X251^2",
         "current_goal_predicate": "copy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -319496,8 +309240,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -319516,8 +309259,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -319541,13 +309283,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -319562,8 +309302,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -319582,13 +309321,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -319613,13 +309350,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -319653,8 +309388,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -319730,13 +309464,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -319751,8 +309483,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -319771,8 +309502,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -319867,13 +309597,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -319965,13 +309693,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -319986,13 +309712,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -320007,13 +309731,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -320028,13 +309750,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -320106,13 +309826,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -320203,13 +309921,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -320243,13 +309959,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -320283,13 +309997,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -320304,13 +310016,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -320610,13 +310320,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -320635,8 +310343,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -320661,13 +310368,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -320682,8 +310387,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -320730,8 +310434,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -320763,8 +310466,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -320783,8 +310485,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -320803,8 +310504,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -320828,13 +310528,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -320849,8 +310547,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -320869,13 +310566,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -320900,13 +310595,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -320940,8 +310633,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -321017,13 +310709,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -321038,8 +310728,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -321058,8 +310747,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -321154,13 +310842,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -321252,13 +310938,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -321273,13 +310957,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -321294,13 +310976,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -321315,13 +310995,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -321393,13 +311071,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -321490,13 +311166,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -321530,13 +311204,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -321570,13 +311242,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -321591,13 +311261,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -321897,13 +311565,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -321922,8 +311588,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -321948,13 +311613,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -321969,8 +311632,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -322011,8 +311673,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -322025,8 +311686,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := c0" ],
-                [ "Assign", "A1 := X253^2" ]
+                [ "Assign", "A0 := c0" ], [ "Assign", "A1 := X253^2" ]
               ]
             },
             "siblings": [
@@ -322044,8 +311704,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -322064,8 +311723,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -322084,8 +311742,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -322104,8 +311761,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -322129,13 +311785,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -322150,8 +311804,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -322170,13 +311823,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -322201,13 +311852,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -322241,8 +311890,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -322318,13 +311966,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -322339,8 +311985,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -322359,8 +312004,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -322455,13 +312099,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -322553,13 +312195,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -322574,13 +312214,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -322595,13 +312233,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -322616,13 +312252,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -322694,13 +312328,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -322791,13 +312423,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -322831,13 +312461,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -322871,13 +312499,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -322892,13 +312518,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -323198,13 +312822,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -323223,8 +312845,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -323249,13 +312870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -323270,8 +312889,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -323327,8 +312945,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -323347,8 +312964,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -323367,8 +312983,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -323387,8 +313002,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -323412,13 +313026,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -323433,8 +313045,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -323453,13 +313064,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -323484,13 +313093,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -323524,8 +313131,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -323601,13 +313207,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -323622,8 +313226,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -323642,8 +313245,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -323738,13 +313340,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -323836,13 +313436,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -323857,13 +313455,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -323878,13 +313474,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -323899,13 +313493,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -323977,13 +313569,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -324074,13 +313664,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -324114,13 +313702,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -324154,13 +313740,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -324175,13 +313759,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -324481,13 +314063,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -324506,8 +314086,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -324532,13 +314111,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -324553,8 +314130,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -324615,8 +314191,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -324635,8 +314210,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -324655,8 +314229,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -324675,8 +314248,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -324700,13 +314272,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -324721,8 +314291,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -324741,13 +314310,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -324772,13 +314339,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -324812,8 +314377,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -324889,13 +314453,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -324910,8 +314472,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -324930,8 +314491,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -325026,13 +314586,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -325124,13 +314682,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -325145,13 +314701,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -325166,13 +314720,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -325187,13 +314739,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -325265,13 +314815,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -325362,13 +314910,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -325402,13 +314948,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -325442,13 +314986,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -325463,13 +315005,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -325769,13 +315309,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -325794,8 +315332,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -325820,13 +315357,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -325841,8 +315376,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -325904,8 +315438,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -325924,8 +315457,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -325944,8 +315476,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -325964,8 +315495,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -325989,13 +315519,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -326010,8 +315538,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -326030,13 +315557,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -326061,13 +315586,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -326101,8 +315624,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -326178,13 +315700,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -326199,8 +315719,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -326219,8 +315738,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -326315,13 +315833,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -326413,13 +315929,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -326434,13 +315948,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -326455,13 +315967,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -326476,13 +315986,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -326554,13 +316062,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -326651,13 +316157,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -326691,13 +316195,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -326731,13 +316233,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -326752,13 +316252,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -327058,13 +316556,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -327083,8 +316579,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -327109,13 +316604,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -327130,8 +316623,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -327178,8 +316670,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -327211,8 +316702,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -327231,8 +316721,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -327251,8 +316740,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -327271,8 +316759,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -327296,13 +316783,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -327317,8 +316802,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -327337,13 +316821,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -327368,13 +316850,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -327408,8 +316888,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -327485,13 +316964,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -327506,8 +316983,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -327526,8 +317002,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -327622,13 +317097,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -327720,13 +317193,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -327741,13 +317212,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -327762,13 +317231,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -327783,13 +317250,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -327861,13 +317326,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -327958,13 +317421,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -327998,13 +317459,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -328038,13 +317497,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -328059,13 +317516,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -328365,13 +317820,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -328390,8 +317843,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -328416,13 +317868,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -328437,8 +317887,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -328479,8 +317928,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -328493,8 +317941,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := c1" ],
-                [ "Assign", "A1 := X255^2" ]
+                [ "Assign", "A0 := c1" ], [ "Assign", "A1 := X255^2" ]
               ]
             },
             "siblings": [
@@ -328512,8 +317959,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -328532,8 +317978,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -328552,8 +317997,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -328572,8 +318016,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -328592,8 +318035,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -328617,13 +318059,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -328638,8 +318078,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -328658,13 +318097,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -328689,13 +318126,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -328729,8 +318164,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -328806,13 +318240,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -328827,8 +318259,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -328847,8 +318278,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -328943,13 +318373,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -329041,13 +318469,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -329062,13 +318488,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -329083,13 +318507,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -329104,13 +318526,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -329182,13 +318602,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -329279,13 +318697,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -329319,13 +318735,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -329359,13 +318773,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -329380,13 +318792,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -329686,13 +319096,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -329711,8 +319119,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -329737,13 +319144,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -329758,8 +319163,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -329815,8 +319219,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -329835,8 +319238,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -329855,8 +319257,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -329875,8 +319276,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -329895,8 +319295,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -329920,13 +319319,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -329941,8 +319338,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -329961,13 +319357,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -329992,13 +319386,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -330032,8 +319424,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -330109,13 +319500,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -330130,8 +319519,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -330150,8 +319538,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -330246,13 +319633,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -330344,13 +319729,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -330365,13 +319748,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -330386,13 +319767,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -330407,13 +319786,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -330485,13 +319862,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -330582,13 +319957,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -330622,13 +319995,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -330662,13 +320033,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -330683,13 +320052,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -330989,13 +320356,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -331014,8 +320379,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -331040,13 +320404,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -331061,8 +320423,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -331123,8 +320484,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -331143,8 +320503,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -331163,8 +320522,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -331183,8 +320541,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -331203,8 +320560,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -331228,13 +320584,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -331249,8 +320603,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -331269,13 +320622,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -331300,13 +320651,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -331340,8 +320689,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -331417,13 +320765,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -331438,8 +320784,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -331458,8 +320803,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -331554,13 +320898,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -331652,13 +320994,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -331673,13 +321013,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -331694,13 +321032,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -331715,13 +321051,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -331793,13 +321127,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -331890,13 +321222,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -331930,13 +321260,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -331970,13 +321298,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -331991,13 +321317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -332297,13 +321621,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -332322,8 +321644,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -332348,13 +321669,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -332369,8 +321688,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -332432,8 +321750,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -332452,8 +321769,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -332472,8 +321788,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -332492,8 +321807,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -332512,8 +321826,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -332537,13 +321850,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -332558,8 +321869,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -332578,13 +321888,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -332609,13 +321917,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -332649,8 +321955,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -332726,13 +322031,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -332747,8 +322050,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -332767,8 +322069,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -332863,13 +322164,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -332961,13 +322260,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -332982,13 +322279,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -333003,13 +322298,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -333024,13 +322317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -333102,13 +322393,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -333199,13 +322488,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -333239,13 +322526,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -333279,13 +322564,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -333300,13 +322583,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -333606,13 +322887,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -333631,8 +322910,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -333657,13 +322935,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -333678,8 +322954,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -333769,8 +323044,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -333789,8 +323063,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -333809,8 +323082,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -333829,8 +323101,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
+                "rule_text": "(copy (app A0) (app A1)) :- (!), (std.map A0 copy A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -333854,13 +323125,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -333875,8 +323144,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -333895,13 +323163,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -333926,13 +323192,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -333966,8 +323230,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -334043,13 +323306,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -334064,8 +323325,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -334084,8 +323344,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -334180,13 +323439,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -334278,13 +323535,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -334299,13 +323554,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -334320,13 +323573,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -334341,13 +323592,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -334419,13 +323668,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -334516,13 +323763,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -334556,13 +323801,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -334596,13 +323839,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -334617,13 +323858,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -334923,13 +324162,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -334948,8 +324185,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -334974,13 +324210,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -334995,8 +324229,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -335037,8 +324270,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                  "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                   "rule_loc": [
                     "File",
                     {
@@ -335076,8 +324308,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -335096,8 +324327,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -335116,13 +324346,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -335147,13 +324375,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -335187,8 +324413,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -335264,13 +324489,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -335285,8 +324508,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -335305,8 +324527,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -335401,13 +324622,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -335499,13 +324718,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -335520,13 +324737,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -335541,13 +324756,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -335562,13 +324775,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -335640,13 +324851,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -335737,13 +324946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -335777,13 +324984,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -335817,13 +325022,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -335838,13 +325041,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -336144,13 +325345,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -336169,8 +325368,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -336195,13 +325393,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -336216,8 +325412,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -336258,13 +325453,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                  "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                       "line": 318,
                       "column": 0,
                       "character": 12866
@@ -336288,8 +325481,7 @@
                 "goal_id": 1828
               },
               {
-                "goal_text":
-                  "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X261^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X261^2 | c6] c3) | X260^2]\n => copy c0 X257^2",
+                "goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X261^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X261^2 | c6] c3) | X260^2]\n => copy c0 X257^2",
                 "goal_id": 1829
               }
             ],
@@ -336302,13 +325494,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -336323,8 +325513,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -336343,8 +325532,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -336363,13 +325551,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -336394,13 +325580,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -336434,8 +325618,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -336511,13 +325694,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -336532,8 +325713,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -336552,8 +325732,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -336648,13 +325827,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -336746,13 +325923,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -336767,13 +325942,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -336788,13 +325961,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -336809,13 +325980,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -336887,13 +326056,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -336984,13 +326151,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -337024,13 +326189,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -337064,13 +326227,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -337085,13 +326246,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -337391,13 +326550,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -337416,8 +326573,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -337442,13 +326598,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -337463,8 +326617,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -337505,13 +326658,11 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                  "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                       "line": 200,
                       "column": 0,
                       "character": 7260
@@ -337540,13 +326691,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -337561,13 +326710,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -337582,8 +326729,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -337602,8 +326748,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -337622,13 +326767,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -337653,13 +326796,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -337693,8 +326834,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -337770,13 +326910,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -337791,8 +326929,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -337811,8 +326948,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -337907,13 +327043,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -338005,13 +327139,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -338026,13 +327158,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -338047,13 +327177,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -338068,13 +327196,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -338146,13 +327272,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -338243,13 +327367,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -338283,13 +327405,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -338323,13 +327443,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -338344,13 +327462,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -338650,13 +327766,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -338675,8 +327789,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -338701,13 +327814,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -338722,8 +327833,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -338764,8 +327874,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                  "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -338784,8 +327893,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "findall_solutions (local-canonical X262^2) X263^2",
+                "goal_text": "findall_solutions (local-canonical X262^2) X263^2",
                 "goal_id": 1832
               }
             ],
@@ -338798,8 +327906,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -338818,13 +327925,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -338839,13 +327944,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -338860,8 +327963,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -338880,8 +327982,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -338900,13 +328001,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -338931,13 +328030,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -338971,8 +328068,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -339048,13 +328144,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -339069,8 +328163,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -339089,8 +328182,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -339185,13 +328277,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -339283,13 +328373,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -339304,13 +328392,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -339325,13 +328411,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -339346,13 +328430,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -339424,13 +328506,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -339521,13 +328601,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -339561,13 +328639,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -339601,13 +328677,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -339622,13 +328696,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -339928,13 +329000,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -339953,8 +329023,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -339979,13 +329048,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -340000,8 +329067,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -340033,8 +329099,7 @@
       "Findall",
       {
         "findall_goal_id": 1832,
-        "findall_goal_text":
-          "findall_solutions (local-canonical X262^2) X263^2",
+        "findall_goal_text": "findall_solutions (local-canonical X262^2) X263^2",
         "findall_cards": [
           {
             "step_id": 0,
@@ -340074,8 +329139,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -340094,13 +329158,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -340115,13 +329177,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -340136,8 +329196,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -340156,8 +329215,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -340176,13 +329234,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -340207,13 +329263,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -340247,8 +329301,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -340324,13 +329377,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -340345,8 +329396,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -340365,8 +329415,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -340461,13 +329510,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -340559,13 +329606,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -340580,13 +329625,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -340601,13 +329644,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -340622,13 +329663,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -340700,13 +329739,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -340797,13 +329834,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -340837,13 +329872,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -340877,13 +329910,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -340898,13 +329929,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -341204,13 +330233,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -341229,8 +330256,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -341255,13 +330281,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -341276,8 +330300,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -341361,13 +330384,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
+                "rule_text": "(findall-local-canonical A0) :- (std.findall (local-canonical A1) A2), \n (std.map A2 local-canonical-gref A0).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 200,
                     "column": 0,
                     "character": 7260
@@ -341382,13 +330403,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -341403,8 +330422,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -341423,8 +330441,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -341443,13 +330460,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -341474,13 +330489,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -341514,8 +330527,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -341591,13 +330603,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -341612,8 +330622,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -341632,8 +330641,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -341728,13 +330736,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -341826,13 +330832,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -341847,13 +330851,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -341868,13 +330870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -341889,13 +330889,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -341967,13 +330965,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -342064,13 +331060,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -342104,13 +331098,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -342144,13 +331136,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -342165,13 +331155,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -342471,13 +331459,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -342496,8 +331482,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -342522,13 +331507,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -342543,8 +331526,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -342589,8 +331571,7 @@
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                      "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                       "line": 196,
                       "column": 0,
                       "character": 7411
@@ -342614,8 +331595,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/stdpp.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 7411
@@ -342630,13 +331610,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -342651,8 +331629,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -342671,8 +331648,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -342691,13 +331667,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -342722,13 +331696,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -342762,8 +331734,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -342839,13 +331810,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -342860,8 +331829,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -342880,8 +331848,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -342976,13 +331943,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -343074,13 +332039,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -343095,13 +332058,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -343116,13 +332077,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -343137,13 +332096,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -343215,13 +332172,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -343312,13 +332267,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -343352,13 +332305,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -343392,13 +332343,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -343413,13 +332362,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -343719,13 +332666,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -343744,8 +332689,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -343770,13 +332714,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -343791,8 +332733,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -343824,8 +332765,7 @@
       "Inference",
       {
         "current_goal_id": 1829,
-        "current_goal_text":
-          "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X261^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X261^2 | c6] c3)] =>\n copy c0 X257^2",
+        "current_goal_text": "[pi c2 \\\n  pi c3 \\\n   pi c4 \\\n    pi c5 \\\n     pi c6 \\\n      pi c7 \\\n       copy (app [global c7 | c2]) (app [global c7 | c3]) :-\n        , (pack? c7 _) (!) (std.rev c2 [c4, c0 | c5]) (copy c0 X261^2) \n         (std.map c5 copy c6) \n         (std.rev [global (const «elpi.hole»), X261^2 | c6] c3)] =>\n copy c0 X257^2",
         "current_goal_predicate": "=>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -343851,13 +332791,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -343872,8 +332810,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -343892,8 +332829,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -343912,13 +332848,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -343943,13 +332877,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -343983,8 +332915,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -344060,13 +332991,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -344081,8 +333010,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -344101,8 +333029,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -344197,13 +333124,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -344295,13 +333220,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -344316,13 +333239,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -344337,13 +333258,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -344358,13 +333277,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -344436,13 +333353,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -344533,13 +333448,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -344573,13 +333486,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -344613,13 +333524,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -344634,13 +333543,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -344940,13 +333847,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -344965,8 +333870,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -344991,13 +333895,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -345012,8 +333914,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -345054,8 +333955,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                  "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                   "rule_loc": [
                     "File",
                     {
@@ -345068,8 +333968,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := c0" ],
-                [ "Assign", "A1 := X257^2" ]
+                [ "Assign", "A0 := c0" ], [ "Assign", "A1 := X257^2" ]
               ]
             },
             "siblings": [
@@ -345087,8 +333986,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -345112,13 +334010,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -345133,8 +334029,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -345153,8 +334048,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -345173,13 +334067,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -345204,13 +334096,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -345244,8 +334134,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -345321,13 +334210,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -345342,8 +334229,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -345362,8 +334248,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -345458,13 +334343,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -345556,13 +334439,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -345577,13 +334458,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -345598,13 +334477,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -345619,13 +334496,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -345697,13 +334572,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -345794,13 +334667,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -345834,13 +334705,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -345874,13 +334743,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -345895,13 +334762,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -346201,13 +335066,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -346226,8 +335089,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -346252,13 +335114,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -346273,8 +335133,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -346330,8 +335189,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -346355,13 +335213,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -346376,8 +335232,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -346396,8 +335251,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -346416,13 +335270,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -346447,13 +335299,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -346487,8 +335337,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -346564,13 +335413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -346585,8 +335432,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -346605,8 +335451,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -346701,13 +335546,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -346799,13 +335642,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -346820,13 +335661,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -346841,13 +335680,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -346862,13 +335699,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -346940,13 +335775,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -347037,13 +335870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -347077,13 +335908,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -347117,13 +335946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -347138,13 +335965,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -347444,13 +336269,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -347469,8 +336292,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -347495,13 +336317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -347516,8 +336336,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -347578,8 +336397,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -347603,13 +336421,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -347624,8 +336440,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -347644,8 +336459,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -347664,13 +336478,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -347695,13 +336507,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -347735,8 +336545,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -347812,13 +336621,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -347833,8 +336640,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -347853,8 +336659,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -347949,13 +336754,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -348047,13 +336850,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -348068,13 +336869,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -348089,13 +336888,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -348110,13 +336907,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -348188,13 +336983,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -348285,13 +337078,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -348325,13 +337116,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -348365,13 +337154,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -348386,13 +337173,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -348692,13 +337477,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -348717,8 +337500,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -348743,13 +337525,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -348764,8 +337544,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -348827,8 +337606,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
+                "rule_text": "(copy A0 A1) :- (name A0), (!), (A0 = A1), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -348852,13 +337630,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
+                "rule_text": "(copy-pack-holes A0 A1 A2) :- (findall-local-canonical A3), \n (coq.copy-clauses-for-unfold A3 A4), \n ([pi (c2 \\\n    (pi (c3 \\\n      (pi (c4 \\\n        (pi (c5 \\\n          (pi (c6 \\\n            (pi (c7 \\\n              (copy (app [global c5 | c0]) (app [global c5 | c1]) :-\n                , (pack? c5 _) (!) (std.rev c0 [c2, A0 | c3]) (copy A0 A5) \n                 (std.map c3 copy c4) \n                 (std.rev [global (const «elpi.hole»), A5 | c4] c1))))))))))))) | A4]\n   => copy A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 318,
                     "column": 0,
                     "character": 12866
@@ -348873,8 +337649,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -348893,8 +337668,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -348913,13 +337687,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -348944,13 +337716,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -348984,8 +337754,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -349061,13 +337830,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -349082,8 +337849,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -349102,8 +337868,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -349198,13 +337963,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -349296,13 +338059,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -349317,13 +338078,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -349338,13 +338097,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -349359,13 +338116,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -349437,13 +338192,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -349534,13 +338287,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -349574,13 +338325,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -349614,13 +338363,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -349635,13 +338382,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -349941,13 +338686,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -349966,8 +338709,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -349992,13 +338734,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -350013,8 +338753,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -350104,8 +338843,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -350124,8 +338862,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.map A1 A2 A4).",
                 "rule_loc": [
                   "File",
                   {
@@ -350144,13 +338881,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -350175,13 +338910,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -350215,8 +338948,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -350292,13 +339024,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -350313,8 +339043,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -350333,8 +339062,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -350429,13 +339157,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -350527,13 +339253,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -350548,13 +339272,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -350569,13 +339291,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -350590,13 +339310,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -350668,13 +339386,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -350765,13 +339481,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -350805,13 +339519,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -350845,13 +339557,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -350866,13 +339576,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -351172,13 +339880,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -351197,8 +339903,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -351223,13 +339928,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -351244,8 +339947,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -351277,8 +339979,7 @@
       "Inference",
       {
         "current_goal_id": 1776,
-        "current_goal_text":
-          "std.spy\n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
+        "current_goal_text": "std.spy\n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
         "current_goal_predicate": "std.spy",
         "failed_attempts": [],
         "successful_attempts": [
@@ -351287,8 +339988,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                  "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                   "rule_loc": [
                     "File",
                     {
@@ -351310,23 +340010,19 @@
             "siblings": [
               { "goal_text": "trace.counter run X264^2", "goal_id": 1841 },
               {
-                "goal_text":
-                  "if (not (X264^2 = 0)) (std.debug-print run= X264^2) true",
+                "goal_text": "if (not (X264^2 = 0)) (std.debug-print run= X264^2) true",
                 "goal_id": 1842
               },
               {
-                "goal_text":
-                  "std.debug-print ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
+                "goal_text": "std.debug-print ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
                 "goal_id": 1843
               },
               {
-                "goal_text":
-                  "std.take 1 \n [app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1], c0] X230^1",
+                "goal_text": "std.take 1 \n [app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1], c0] X230^1",
                 "goal_id": 1844
               },
               {
-                "goal_text":
-                  "std.debug-print ---->>---- exit:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
+                "goal_text": "std.debug-print ---->>---- exit:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
                 "goal_id": 1845
               }
             ],
@@ -351339,8 +340035,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -351359,13 +340054,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -351390,13 +340083,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -351430,8 +340121,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -351507,13 +340197,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -351528,8 +340216,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -351548,8 +340235,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -351644,13 +340330,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -351742,13 +340426,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -351763,13 +340445,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -351784,13 +340464,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -351805,13 +340483,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -351883,13 +340559,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -351980,13 +340654,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -352020,13 +340692,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -352060,13 +340730,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -352081,13 +340749,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -352387,13 +341053,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -352412,8 +341076,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -352438,13 +341101,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -352459,8 +341120,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -352516,8 +341176,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -352536,13 +341195,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -352567,13 +341224,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -352607,8 +341262,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -352684,13 +341338,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -352705,8 +341357,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -352725,8 +341376,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -352821,13 +341471,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -352919,13 +341567,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -352940,13 +341586,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -352961,13 +341605,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -352982,13 +341624,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -353060,13 +341700,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -353157,13 +341795,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -353197,13 +341833,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -353237,13 +341871,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -353258,13 +341890,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -353564,13 +342194,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -353589,8 +342217,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -353615,13 +342242,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -353636,8 +342261,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -353698,8 +342322,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -353718,13 +342341,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -353749,13 +342370,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -353789,8 +342408,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -353866,13 +342484,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -353887,8 +342503,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -353907,8 +342522,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -354003,13 +342617,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -354101,13 +342713,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -354122,13 +342732,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -354143,13 +342751,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -354164,13 +342770,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -354242,13 +342846,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -354339,13 +342941,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -354379,13 +342979,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -354419,13 +343017,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -354440,13 +343036,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -354746,13 +343340,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -354771,8 +343363,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -354797,13 +343388,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -354818,8 +343407,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -354910,8 +343498,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -354930,13 +343517,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -354961,13 +343546,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -355001,8 +343584,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -355078,13 +343660,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -355099,8 +343679,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -355119,8 +343698,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -355215,13 +343793,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -355313,13 +343889,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -355334,13 +343908,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -355355,13 +343927,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -355376,13 +343946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -355454,13 +344022,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -355551,13 +344117,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -355591,13 +344155,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -355631,13 +344193,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -355652,13 +344212,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -355958,13 +344516,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -355983,8 +344539,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -356009,13 +344564,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -356030,8 +344583,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -356138,8 +344690,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -356158,13 +344709,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -356189,13 +344738,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -356229,8 +344776,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -356306,13 +344852,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -356327,8 +344871,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -356347,8 +344890,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -356443,13 +344985,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -356541,13 +345081,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -356562,13 +345100,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -356583,13 +345119,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -356604,13 +345138,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -356682,13 +345214,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -356779,13 +345309,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -356819,13 +345347,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -356859,13 +345385,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -356880,13 +345404,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -357186,13 +345708,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -357211,8 +345731,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -357237,13 +345756,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -357258,8 +345775,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -357353,8 +345869,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -357373,13 +345888,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -357404,13 +345917,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -357444,8 +345955,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -357521,13 +346031,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -357542,8 +346050,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -357562,8 +346069,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -357658,13 +346164,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -357756,13 +346260,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -357777,13 +346279,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -357798,13 +346298,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -357819,13 +346317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -357897,13 +346393,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -357994,13 +346488,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -358034,13 +346526,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -358074,13 +346564,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -358095,13 +346583,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -358401,13 +346887,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -358426,8 +346910,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -358452,13 +346935,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -358473,8 +346954,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -358585,8 +347065,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -358605,13 +347084,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -358636,13 +347113,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -358676,8 +347151,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -358753,13 +347227,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -358774,8 +347246,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -358794,8 +347265,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -358890,13 +347360,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -358988,13 +347456,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -359009,13 +347475,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -359030,13 +347494,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -359051,13 +347513,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -359129,13 +347589,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -359226,13 +347684,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -359266,13 +347722,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -359306,13 +347760,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -359327,13 +347779,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -359633,13 +348083,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -359658,8 +348106,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -359684,13 +348131,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -359705,8 +348150,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -359790,8 +348234,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -359810,13 +348253,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -359841,13 +348282,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -359881,8 +348320,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -359958,13 +348396,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -359979,8 +348415,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -359999,8 +348434,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -360095,13 +348529,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -360193,13 +348625,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -360214,13 +348644,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -360235,13 +348663,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -360256,13 +348682,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -360334,13 +348758,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -360431,13 +348853,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -360471,13 +348891,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -360511,13 +348929,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -360532,13 +348948,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -360838,13 +349252,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -360863,8 +349275,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -360889,13 +349300,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -360910,8 +349319,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -361014,8 +349422,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -361034,13 +349441,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -361065,13 +349470,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -361105,8 +349508,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -361182,13 +349584,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -361203,8 +349603,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -361223,8 +349622,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -361319,13 +349717,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -361417,13 +349813,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -361438,13 +349832,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -361459,13 +349851,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -361480,13 +349870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -361558,13 +349946,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -361655,13 +350041,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -361695,13 +350079,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -361735,13 +350117,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -361756,13 +350136,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -362062,13 +350440,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -362087,8 +350463,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -362113,13 +350488,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -362134,8 +350507,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -362167,8 +350539,7 @@
       "Inference",
       {
         "current_goal_id": 1843,
-        "current_goal_text":
-          "std.debug-print ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
+        "current_goal_text": "std.debug-print ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
         "current_goal_predicate": "std.debug-print",
         "failed_attempts": [],
         "successful_attempts": [
@@ -362177,8 +350548,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
+                  "rule_text": "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -362201,8 +350571,7 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1854 },
               {
-                "goal_text":
-                  "coq.say ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
+                "goal_text": "coq.say ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
                 "goal_id": 1855
               }
             ],
@@ -362215,8 +350584,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
+                "rule_text": "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -362235,8 +350603,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -362255,13 +350622,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -362286,13 +350651,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -362326,8 +350689,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -362403,13 +350765,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -362424,8 +350784,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -362444,8 +350803,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -362540,13 +350898,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -362638,13 +350994,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -362659,13 +351013,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -362680,13 +351032,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -362701,13 +351051,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -362779,13 +351127,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -362876,13 +351222,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -362916,13 +351260,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -362956,13 +351298,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -362977,13 +351317,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -363283,13 +351621,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -363308,8 +351644,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -363334,13 +351669,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -363355,8 +351688,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -363391,8 +351723,7 @@
         "cut_victims": [
           {
             "cut_branch_for_goal": {
-              "goal_text":
-                "std.debug-print ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
+              "goal_text": "std.debug-print ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
               "goal_id": 1843
             },
             "cut_branch": {
@@ -363420,8 +351751,7 @@
       "Inference",
       {
         "current_goal_id": 1855,
-        "current_goal_text":
-          "coq.say ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
+        "current_goal_text": "coq.say ----<<---- enter:  \n (std.take 1 \n   [app\n     [global\n       (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n      c0, c1], c0] X230^1)",
         "current_goal_predicate": "coq.say",
         "failed_attempts": [],
         "successful_attempts": [
@@ -363445,8 +351775,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
+                "rule_text": "(std.debug-print A0 A1) :- (!), (coq.say A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -363465,8 +351794,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -363485,13 +351813,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -363516,13 +351842,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -363556,8 +351880,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -363633,13 +351956,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -363654,8 +351975,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -363674,8 +351994,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -363770,13 +352089,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -363868,13 +352185,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -363889,13 +352204,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -363910,13 +352223,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -363931,13 +352242,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -364009,13 +352318,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -364106,13 +352413,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -364146,13 +352451,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -364186,13 +352489,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -364207,13 +352508,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -364513,13 +352812,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -364538,8 +352835,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -364564,13 +352860,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -364585,8 +352879,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -364618,16 +352911,14 @@
       "Inference",
       {
         "current_goal_id": 1844,
-        "current_goal_text":
-          "std.take 1 \n [app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1], c0] X230^1",
+        "current_goal_text": "std.take 1 \n [app\n   [global\n     (const «Builders_18.Builders_18_T__canonical__interleave_context_A»), \n    c0, c1], c0] X230^1",
         "current_goal_predicate": "std.take",
         "failed_attempts": [
           {
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.take _ _ _) :- (std.fatal-error take run out of list items).",
+                "rule_text": "(std.take _ _ _) :- (std.fatal-error take run out of list items).",
                 "rule_loc": [
                   "File",
                   {
@@ -364648,8 +352939,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
+                  "rule_text": "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
                   "rule_loc": [
                     "File",
                     {
@@ -364689,8 +352979,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
+                "rule_text": "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -364709,8 +352998,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -364729,13 +353017,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -364760,13 +353046,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -364800,8 +353084,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -364877,13 +353160,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -364898,8 +353179,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -364918,8 +353198,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -365014,13 +353293,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -365112,13 +353389,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -365133,13 +353408,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -365154,13 +353427,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -365175,13 +353446,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -365253,13 +353522,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -365350,13 +353617,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -365390,13 +353655,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -365430,13 +353693,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -365451,13 +353712,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -365757,13 +354016,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -365782,8 +354039,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -365808,13 +354064,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -365829,8 +354083,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -365920,8 +354173,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
+                "rule_text": "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -365940,8 +354192,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -365960,13 +354211,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -365991,13 +354240,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -366031,8 +354278,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -366108,13 +354354,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -366129,8 +354373,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -366149,8 +354392,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -366245,13 +354487,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -366343,13 +354583,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -366364,13 +354602,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -366385,13 +354621,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -366406,13 +354640,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -366484,13 +354716,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -366581,13 +354811,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -366621,13 +354849,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -366661,13 +354887,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -366682,13 +354906,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -366988,13 +355210,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -367013,8 +355233,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -367039,13 +355258,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -367060,8 +355277,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -367131,8 +355347,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(stop A0) :- (get-option ltac:fail A1), (!), (coq.ltac.fail A1 A0).",
+                "rule_text": "(stop A0) :- (get-option ltac:fail A1), (!), (coq.ltac.fail A1 A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -367171,8 +355386,7 @@
               { "goal_text": "get-option ltac:fail X265^2", "goal_id": 1859 },
               { "goal_text": "!", "goal_id": 1860 },
               {
-                "goal_text":
-                  "coq.ltac.fail X265^2 take run out of list items",
+                "goal_text": "coq.ltac.fail X265^2 take run out of list items",
                 "goal_id": 1861
               }
             ],
@@ -367223,8 +355437,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
+                "rule_text": "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -367243,8 +355456,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -367263,13 +355475,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -367294,13 +355504,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -367334,8 +355542,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -367411,13 +355618,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -367432,8 +355637,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -367452,8 +355656,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -367548,13 +355751,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -367646,13 +355847,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -367667,13 +355866,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -367688,13 +355885,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -367709,13 +355904,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -367787,13 +355980,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -367884,13 +356075,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -367924,13 +356113,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -367964,13 +356151,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -367985,13 +356170,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -368291,13 +356474,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -368316,8 +356497,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -368342,13 +356522,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -368363,8 +356541,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -368444,8 +356621,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
+                "rule_text": "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -368464,8 +356640,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -368484,13 +356659,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -368515,13 +356688,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -368555,8 +356726,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -368632,13 +356802,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -368653,8 +356821,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -368673,8 +356840,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -368769,13 +356935,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -368867,13 +357031,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -368888,13 +357050,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -368909,13 +357069,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -368930,13 +357088,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -369008,13 +357164,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -369105,13 +357259,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -369145,13 +357297,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -369185,13 +357335,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -369206,13 +357354,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -369512,13 +357658,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -369537,8 +357681,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -369563,13 +357706,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -369584,8 +357725,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
@@ -369693,8 +357833,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
+                "rule_text": "(std.take A0 [A1 | A2] [A1 | A3]) :- (!), (A4 is A0 - 1), \n (std.take A4 A2 A3).",
                 "rule_loc": [
                   "File",
                   {
@@ -369713,8 +357852,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
+                "rule_text": "(std.spy A0) :- (trace.counter run A1), \n (if (not (A1 = 0)) (std.debug-print run= A1) true), \n (std.debug-print ----<<---- enter:  A0), A0, \n (std.debug-print ---->>---- exit:  A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -369733,13 +357871,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c2 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -369764,13 +357900,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
+                "rule_text": "(extract-conclusion-params A0 (prod _ A1 A2) A3) :- (!), \n (pi (c1 \\ (decl c0 _ A1 => extract-conclusion-params A0 (A2 c0) A3))).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 115,
                     "column": 0,
                     "character": 3974
@@ -369804,8 +357938,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
+                "rule_text": "(std.assert! A0 A1) :- (A0 ; std.fatal-error-w-data A1 A0), (!).",
                 "rule_loc": [
                   "File",
                   {
@@ -369881,13 +358014,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
+                "rule_text": "(factory-provides.one A0 A1 A2 A3 (triple A3 A4 A1)) :- (std.do!\n                                                          [std.assert-ok!\n                                                            (coq.typecheck\n                                                              A2 A5) \n                                                            Builder illtyped, \n                                                           (coq.subst-prod\n                                                             A0 A5 A7 ,\n                                                             coq.subst-prod\n                                                              [A1] A7 A6), \n                                                           std.assert!\n                                                            (extract-conclusion-params\n                                                              A1 A6 A4) \n                                                            The conclusion of a builder is a mixin whose parameters depend on other mixins]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 108,
                     "column": 0,
                     "character": 3601
@@ -369902,8 +358033,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -369922,8 +358052,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
+                "rule_text": "(std.map2 [A0 | A1] [A2 | A3] A4 [A5 | A6]) :- (A4 A0 A2 A5), \n (std.map2 A1 A3 A4 A6).",
                 "rule_loc": [
                   "File",
                   {
@@ -370018,13 +358147,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
+                "rule_text": "(factory-provides.base A0 A1 A2 _ A3) :- (std.do!\n                                           [std.findall (from A0 A4 A5) A6, \n                                            std.map A6 from_mixin A7, \n                                            std.map A6 from_builder A8, \n                                            std.map2 A8 A7 \n                                             (factory-provides.one A1 A2) A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 3290
@@ -370116,13 +358243,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
+                "rule_text": "(w-params.fold.params (w-params.nil A0 A1 A2) _ A3 A4 A5) :- (!), \n (std.do! [coq.id->name A0 A6, std.rev A4 A7, A3 A7 A6 A1 A2 A5]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 224,
                     "column": 0,
                     "character": 8609
@@ -370137,13 +358262,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
+                "rule_text": "(w-params.fold A0 A1 A2 A3) :- (w-params.fold.params A0 A1 A2 [] A3).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 213,
                     "column": 0,
                     "character": 8143
@@ -370158,13 +358281,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
+                "rule_text": "(w-params.then A0 A1 A2 A3 A4) :- (w-params.fold A0 A1 (c0 \\ (c1 \\ (c2 \\\n                                    (c3 \\ (c4 \\\n                                    (sigma (c5 \\\n                                      (pi (c6 \\\n                                        (decl c6 c1 c2 =>\n                                          A3 c0 c6 (c3 c6) (c5 c6))) ,\n                                        A2 c1 c2 c5 c4)))))))) A4).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 239,
                     "column": 0,
                     "character": 9183
@@ -370179,13 +358300,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
+                "rule_text": "(w-params.map A0 A1 A2) :- (w-params.then A0 mk-w-params.cons-name \n                             mk-w-params.nil-name A1 A2).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 245,
                     "column": 0,
                     "character": 9440
@@ -370257,13 +358376,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
+                "rule_text": "(factory-provides A0 A1) :- (std.do!\n                              [factory-alias->gref A0 A2, gref-deps A2 A3, \n                               w-params.map A3 (factory-provides.base A2) A1]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/database.elpi",
                     "line": 86,
                     "column": 0,
                     "character": 2829
@@ -370354,13 +358471,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
+                "rule_text": "(synthesis.private.factory-instance->new-mixins A0 A1 A2) :- (std.do!\n                                                               [std.assert-ok!\n                                                                 (coq.typecheck\n                                                                   A1 A3) \n                                                                 mixin-src: X illtyped, \n                                                                if\n                                                                 (not\n                                                                   (coq.safe-dest-app\n                                                                    A3 \n                                                                    (global _) \n                                                                    _)) \n                                                                 (,\n                                                                   (coq.term->string\n                                                                    A1 A7) \n                                                                   (coq.term->string\n                                                                    A3 A8) \n                                                                   (coq.error\n                                                                    Term:\n \n                                                                    A7 \n                                                                    \nhas type:\n \n                                                                    A8 \n                                                                    \nwhich is not a record)) \n                                                                 true, \n                                                                coq.term->gref\n                                                                 A3 A4, \n                                                                factory-provides\n                                                                 A4 A5, \n                                                                list-w-params_list\n                                                                 A5 A6, \n                                                                std.filter\n                                                                 A6 (c0 \\\n                                                                 (not\n                                                                   (std.mem!\n                                                                    A0 c0))) \n                                                                 A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 12694
@@ -370394,13 +358509,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
+                "rule_text": "(synthesis.under-mixin-src-from-factory.do! A0 A1 A2) :- (std.do!\n                                                           [synthesis.private.factory-instance->new-mixins\n                                                             [] A1 A3, \n                                                            std.map A3 (c0 \\\n                                                             (c1 \\\n                                                             (c1 =\n                                                               mixin-src A0 \n                                                                c0 A1))) A4, \n                                                            A4 => std.do! A2]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/synthesis.elpi",
                     "line": 100,
                     "column": 0,
                     "character": 4390
@@ -370434,13 +358547,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
+                "rule_text": "(instance.private.declare-canonical-instances-from-factory A0 A1 A2 A3) :- (\n std.do!\n  [synthesis.under-mixin-src-from-factory.do! A1 A2 \n    [synthesis.under-local-canonical-mixins-of.do! A1 \n      [(factory-provides A0 A7 , list-w-params_list A7 A4), \n       instance.private.add-all-mixins A1 A0 A4 tt _ A5, \n       (findall-classes-for A4 A8 , instance.declare-all A1 A8 A6)]], \n   std.append A5 A6 A3]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 282,
                     "column": 0,
                     "character": 12180
@@ -370455,13 +358566,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
+                "rule_text": "(instance.private.declare-instance A0 A1 A2 A3 A4) :- (instance.private.declare-canonical-instances-from-factory\n                                                        A0 A1 A2 A4), \n (if (get-option export tt) \n   (coq.env.current-library A5 ,\n     std.map A4 (c0 \\ (c1 \\\n      (sigma (c2 \\\n        (sigma (c3 \\ (c0 = pr c2 c3 , c1 = instance-to-export A5 c2 c3))))))) \n      A3) (A3 = [])).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 196,
                     "column": 0,
                     "character": 8410
@@ -370761,13 +358870,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std.do!\n                                          [std.assert-ok!\n                                            (coq.elaborate-arity-skeleton A2 \n                                              _ A4) Definition type illtyped, \n                                           coq.arity->term A4 A5, \n                                           std.assert-ok!\n                                            (coq.elaborate-skeleton A1 A5 A6) \n                                            Definition illtyped, \n                                           if (A4 = arity A7) \n                                            (if-verbose\n                                              (coq.say\n                                                HB: skipping section opening)\n                                              , A8 = A6) \n                                            (,\n                                              (, (new_int A21) \n                                                (std.any->string A21 A22) \n                                                (A9 is hb_instance_ ^ A22)) \n                                              (log.coq.env.begin-section A9) \n                                              (instance.private.postulate-arity\n                                                A4 [] A6 A8 A7)), \n                                           std.assert!\n                                            (coq.safe-dest-app A7 \n                                              (global A10) A11) \n                                            The type of the instance is not a factory, \n                                           factory-alias->gref A10 A12, \n                                           std.assert!\n                                            (factory-nparams A12 A13) \n                                            Not a factory synthesized by HB, \n                                           instance.private.hack-section-discharging\n                                            A8 A14, \n                                           instance.private.optimize-body\n                                            A14 A15, \n                                           if (A0 = _) \n                                            (, (new_int A23) \n                                              (std.any->string A23 A24) \n                                              (A16 is\n                                                HB_unnamed_factory_ ^ A24)) \n                                            (A16 = A0), \n                                           log.coq.env.add-const-noimplicits-failondup\n                                            A16 A15 A7 ff A17, \n                                           A18 = global (const A17), \n                                           std.drop A13 A11 [A19 | _], \n                                           instance.private.check-non-forgetful-inheritance\n                                            A19 A12, \n                                           instance.private.declare-instance\n                                            A12 A19 A18 A20 A3, \n                                           if (A4 = arity _) true \n                                            (if-verbose\n                                              (header A25 ,\n                                                coq.say A25 \n                                                 closing instance section) ,\n                                              log.coq.env.end-section-name A9), \n                                           acc-clauses current A20]).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/instance.elpi",
                     "line": 25,
                     "column": 0,
                     "character": 1064
@@ -370786,8 +358893,7 @@
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/log.elpi",
                     "line": 289,
                     "column": 0,
                     "character": 11419
@@ -370812,13 +358918,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n                   , (if (c3 = ) (c7 = c0) (c7 is c3 ^ . ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n                    (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (supported-attribute (att c8 string) :- !)) =>\n                      parse-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c6] c4))))))))))))))))) =>\n   coq.parse-attributes A1 \n    [att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type string, att short.pack string, att infer attmap, \n     att key string, att arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercions bool, att export bool, att skip string, \n     att local bool, att fail bool, att doc string, \n     att primitive_class bool, att primitive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 => (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
+                    "filename": "/home/gares/MATHCOMP/hierarchy-builder/HB/common/utils.elpi",
                     "line": 14,
                     "column": 0,
                     "character": 453
@@ -370833,8 +358937,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
+                "rule_text": "(main [const-decl A0 (some A1) A2]) :- (!), \n (with-attributes (with-logging (instance.declare-const A0 A1 A2 _))).",
                 "rule_loc": [
                   "File",
                   {
diff --git a/tests/sources/trace.elab.json b/tests/sources/trace.elab.json
index 732f1cec..a4127fac 100644
--- a/tests/sources/trace.elab.json
+++ b/tests/sources/trace.elab.json
@@ -271,8 +271,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := 1" ],
-                [ "Assign", "A1 := 2 + 3" ]
+                [ "Assign", "A0 := 1" ], [ "Assign", "A1 := 2 + 3" ]
               ]
             },
             "siblings": [ { "goal_text": "calc (2 + 3) 1", "goal_id": 8 } ],
diff --git a/tests/sources/trace2.elab.json b/tests/sources/trace2.elab.json
index 9c00563e..c53c205b 100644
--- a/tests/sources/trace2.elab.json
+++ b/tests/sources/trace2.elab.json
@@ -21,8 +21,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
+                  "rule_text": "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
                   "rule_loc": [
                     "File",
                     {
@@ -52,8 +51,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
+                "rule_text": "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
                 "rule_loc": [
                   "File",
                   {
@@ -104,8 +102,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
+                "rule_text": "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
                 "rule_loc": [
                   "File",
                   {
@@ -161,8 +158,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
+                "rule_text": "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
                 "rule_loc": [
                   "File",
                   {
@@ -220,8 +216,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
+                "rule_text": "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
                 "rule_loc": [
                   "File",
                   {
@@ -282,8 +277,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
+                "rule_text": "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
                 "rule_loc": [
                   "File",
                   {
@@ -352,8 +346,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
+                "rule_text": "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
                 "rule_loc": [
                   "File",
                   {
@@ -452,8 +445,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
+                "rule_text": "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
                 "rule_loc": [
                   "File",
                   {
@@ -530,8 +522,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
+                "rule_text": "main :- (print 1), (pi (c0 \\ (sigma (c1 \\ (fail => (true , fail)))))).",
                 "rule_loc": [
                   "File",
                   {
diff --git a/tests/sources/trace_chr.elab.json b/tests/sources/trace_chr.elab.json
index f18c236c..0b8b977e 100644
--- a/tests/sources/trace_chr.elab.json
+++ b/tests/sources/trace_chr.elab.json
@@ -21,8 +21,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                  "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                   "rule_loc": [
                     "File",
                     {
@@ -51,8 +50,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -88,8 +86,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
+                  "rule_text": "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
                   "rule_loc": [
                     "File",
                     {
@@ -118,8 +115,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
+                "rule_text": "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -138,8 +134,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -178,8 +173,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
+                "rule_text": "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -198,8 +192,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -238,8 +231,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -274,8 +266,7 @@
             "attempt": {
               "rule": [ "BuiltinRule", [ "Logic", "eq" ] ],
               "events": [
-                [ "Assign", "X0 := s X1" ],
-                [ "ResumeGoal", [ 11, 10 ] ]
+                [ "Assign", "X0 := s X1" ], [ "ResumeGoal", [ 11, 10 ] ]
               ]
             },
             "siblings": [],
@@ -293,8 +284,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -395,8 +385,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -485,8 +474,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
+                "rule_text": "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -505,8 +493,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -542,8 +529,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(odd (as uvar A0)) :- (declare_constraint (odd A0) A0).",
+                  "rule_text": "(odd (as uvar A0)) :- (declare_constraint (odd A0) A0).",
                   "rule_loc": [
                     "File",
                     {
@@ -572,8 +558,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(odd (as uvar A0)) :- (declare_constraint (odd A0) A0).",
+                "rule_text": "(odd (as uvar A0)) :- (declare_constraint (odd A0) A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -621,8 +606,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
+                "rule_text": "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -641,8 +625,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -681,8 +664,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(odd (as uvar A0)) :- (declare_constraint (odd A0) A0).",
+                "rule_text": "(odd (as uvar A0)) :- (declare_constraint (odd A0) A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -730,8 +712,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
+                "rule_text": "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -750,8 +731,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -834,8 +814,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -871,8 +850,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
+                  "rule_text": "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
                   "rule_loc": [
                     "File",
                     {
@@ -901,8 +879,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
+                "rule_text": "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -940,8 +917,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -980,8 +956,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
+                "rule_text": "(even (as uvar A0)) :- (declare_constraint (even A0) A0).",
                 "rule_loc": [
                   "File",
                   {
@@ -1019,8 +994,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
@@ -1097,8 +1071,7 @@
                   "step_id": 0,
                   "runtime_id": 2,
                   "step": [
-                    "Init",
-                    { "goal_text": "odd (s z)", "goal_id": 23 }
+                    "Init", { "goal_text": "odd (s z)", "goal_id": 23 }
                   ],
                   "color": "Grey"
                 },
@@ -1122,8 +1095,7 @@
                                 "rule_loc": [
                                   "File",
                                   {
-                                    "filename":
-                                      "tests/sources/trace_chr.elpi",
+                                    "filename": "tests/sources/trace_chr.elpi",
                                     "line": 13,
                                     "column": 0,
                                     "character": 209
@@ -1185,8 +1157,7 @@
                                 "rule_loc": [
                                   "File",
                                   {
-                                    "filename":
-                                      "tests/sources/trace_chr.elpi",
+                                    "filename": "tests/sources/trace_chr.elpi",
                                     "line": 11,
                                     "column": 0,
                                     "character": 200
@@ -1374,8 +1345,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
+                "rule_text": "main :- (even A0), (declare_constraint true A0), (A0 = s A1), \n (not (even A1)).",
                 "rule_loc": [
                   "File",
                   {
diff --git a/tests/sources/trace_findall.elab.json b/tests/sources/trace_findall.elab.json
index f96f0bd6..9f521bd1 100644
--- a/tests/sources/trace_findall.elab.json
+++ b/tests/sources/trace_findall.elab.json
@@ -84,8 +84,7 @@
               "rule": [
                 "UserRule",
                 {
-                  "rule_text":
-                    "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                  "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                   "rule_loc": [
                     "File",
                     {
@@ -98,8 +97,7 @@
                 }
               ],
               "events": [
-                [ "Assign", "A0 := p _" ],
-                [ "Assign", "A1 := X0" ]
+                [ "Assign", "A0 := p _" ], [ "Assign", "A1 := X0" ]
               ]
             },
             "siblings": [
@@ -114,8 +112,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {
@@ -440,8 +437,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.findall A0 A1) :- (findall_solutions A0 A1).",
+                "rule_text": "(std.findall A0 A1) :- (findall_solutions A0 A1).",
                 "rule_loc": [
                   "File",
                   {

From 03c518ed18600d15b32a737a1a61a0d991a7de61 Mon Sep 17 00:00:00 2001
From: Julien Puydt <julien.puydt@gmail.com>
Date: Tue, 25 Oct 2022 10:25:41 +0200
Subject: [PATCH 2/2] Tighten the dependency on atd in elpi.opam

---
 elpi.opam | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/elpi.opam b/elpi.opam
index 0421d9f9..0ab0267b 100644
--- a/elpi.opam
+++ b/elpi.opam
@@ -25,8 +25,8 @@ depends: [
   "cmdliner" {with-test}
   "dune" {>= "2.8.0"}
   "conf-time" {with-test}
-  "atdgen" {>= "2.9.1" & < "2.10.0"}
-  "atdts" {>= "2.9.1" & < "2.10.0"}
+  "atdgen" {>= "2.10.0"}
+  "atdts" {>= "2.10.0"}
   "odoc" {with-doc}
 ]
 depopts: [

[bug#58310] Manifest for coq-mathcomp-analysis

[Julien Lepiller]

[-- Attachment #1: Type: text/plain, Size: 1890 bytes --]

Hi!

I tried building your file (it's technically not a manifest) and indeed it's failing in the chack-findlib-path.

Why do you want to run it? There's no way it could work at this point, right after the check phase, since the package is not even installed yet. Also, the OCAMLPATH that would allow findlib to find it is not set to the outputs, only to the inputs.

Le 13 novembre 2022 00:48:50 GMT+01:00, Garek Dyszel <garekdyszel@disroot.org> a écrit :
>Hi,
>
>CC: ocaml team
>
>I am including a manifest file instead of sending patches for now. It
>seems like a good idea to stick with that until these packages are ready
>to be put into the Guix source tree. I'm refactoring them too often.
>
>After opening an issue on Github [1] [2], it seems that coq-elpi is the
>package that is not building properly. It is clear that ocamlfind (from
>ocaml-findlib) can't find coq-elpi after coq-elpi's install phase.
>[1]: https://github.com/math-comp/hierarchy-builder/issues/320
>[2]: https://github.com/LPCIC/coq-elpi/issues/384
>
>It looks like the META file is not being installed by coq-elpi either.
>I'm not sure whether that's relevant, since ocamlfind couldn't find
>coq-elpi even when META was present (in a much older revision of this
>manifest; I can dig for it but just today don't have time).
>
>The problem seems to be something in the build process itself; if the
>extra phase 'check-findlib-path' is omitted then coq-elpi's build is
>reported as a success.
>
>The later package coq-mathcomp-hierarchy-builder runs ocamlfind to find
>coq-elpi, too.
>
>What would be a way to ensure that coq-elpi is found by ocamlfind? 
>
>Thanks!
>Garek
>
>(Manifest attached with an ocaml-elpi patch. You will need to change the path for
>the ocaml-elpi (patches) field to match your directory structure, but otherwise
>this manifest should work.)
>

[-- Attachment #2: Type: text/html, Size: 2323 bytes --]

[bug#58310] Manifest for coq-mathcomp-analysis

[Julien Lepiller]

[-- Attachment #1: Type: text/plain, Size: 2413 bytes --]

So, I've had a further look at the sources for the failing packages and
figured that some variables were missing in the make-flags. Attached is
the fixed version of your file that builds coq-mathcomp-analysis. Note
that the build of mathcomp-analysis is very quiet and takes a long time,
but it works eventually.

Le Sun, 13 Nov 2022 10:17:07 +0100,
Julien Lepiller <julien@lepiller.eu> a écrit :

> Hi!
> 
> I tried building your file (it's technically not a manifest) and
> indeed it's failing in the chack-findlib-path.
> 
> Why do you want to run it? There's no way it could work at this
> point, right after the check phase, since the package is not even
> installed yet. Also, the OCAMLPATH that would allow findlib to find
> it is not set to the outputs, only to the inputs.
> 
> Le 13 novembre 2022 00:48:50 GMT+01:00, Garek Dyszel
> <garekdyszel@disroot.org> a écrit :
> >Hi,
> >
> >CC: ocaml team
> >
> >I am including a manifest file instead of sending patches for now. It
> >seems like a good idea to stick with that until these packages are
> >ready to be put into the Guix source tree. I'm refactoring them too
> >often.
> >
> >After opening an issue on Github [1] [2], it seems that coq-elpi is
> >the package that is not building properly. It is clear that
> >ocamlfind (from ocaml-findlib) can't find coq-elpi after coq-elpi's
> >install phase. [1]:
> >https://github.com/math-comp/hierarchy-builder/issues/320 [2]:
> >https://github.com/LPCIC/coq-elpi/issues/384
> >
> >It looks like the META file is not being installed by coq-elpi
> >either. I'm not sure whether that's relevant, since ocamlfind
> >couldn't find coq-elpi even when META was present (in a much older
> >revision of this manifest; I can dig for it but just today don't
> >have time).
> >
> >The problem seems to be something in the build process itself; if the
> >extra phase 'check-findlib-path' is omitted then coq-elpi's build is
> >reported as a success.
> >
> >The later package coq-mathcomp-hierarchy-builder runs ocamlfind to
> >find coq-elpi, too.
> >
> >What would be a way to ensure that coq-elpi is found by ocamlfind? 
> >
> >Thanks!
> >Garek
> >
> >(Manifest attached with an ocaml-elpi patch. You will need to change
> >the path for the ocaml-elpi (patches) field to match your directory
> >structure, but otherwise this manifest should work.)
> >  


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: coq-mathcomp-analysis.scm --]
[-- Type: text/x-scheme, Size: 37383 bytes --]

;; -*- mode: scheme; mode: guix-devel -*-
;;; Local Variables:
;;; sentence-end-double-space: t
;;; End:
;;; This module extends GNU Guix and is licensed under the same terms, those
;;; of the GNU GPL version 3 or (at your option) any later version.
;;;
;;; Copyright © 2022 Garek Dyszel

;; To build directly from this file, use the following command.
;; guix build --with-patch=ocaml-elpi=patches/ocaml-elpi-fix-yojson.patch -Kf coq-mathcomp-analysis.scm

(define-module (coq-mathcomp-analysis)
  #:use-module (guix)
  #:use-module (guix git-download)
  #:use-module (guix download)
  #:use-module (guix packages)
  #:use-module (guix build-system gnu)
  #:use-module (guix build gnu-build-system)
  #:use-module (guix build-system dune)
  #:use-module (guix build-system ocaml)
  #:use-module (guix build-system pyproject)
  ;; #:use-module ((guix build utils) #:prefix utils:)
  #:use-module ((guix licenses)
                #:prefix license:)
  #:use-module ((gnu packages base)
                #:prefix base:)
  #:use-module (guix build utils)
  #:use-module (guix utils)
  #:use-module (guix profiles)
  #:use-module (gnu packages)
  #:use-module (gnu packages coq)
  #:use-module (gnu packages base)
  #:use-module (gnu packages ocaml)
  #:use-module (gnu packages time)
  #:use-module (gnu packages python)
  #:use-module (gnu packages python-xyz)
  #:use-module (gnu packages python-build)
  #:use-module (gnu packages python-web)
  #:use-module (gnu packages python-crypto)
  #:use-module (gnu packages xdisorg)
  #:use-module (guix build-system python)
  #:use-module (gnu packages python-check)
  #:use-module (gnu packages check)
  #:use-module (gnu packages java)
  #:use-module (gnu packages python-compression)
  #:use-module (gnu packages lua)
  #:use-module (gnu packages version-control))

;;; Python
(define-public python-pprintpp
  ;; Git version tags are inaccurate for this package; use the
  ;; bare commit.
  (let ((commit "7ede6da1f3062bbfb32ee04353d675a5bff185e0")
        (revision "1"))
    (package
      (name "python-pprintpp")
      (version (git-version "0.3.0" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/wolever/pprintpp")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "0nk935m3ig8sc32laqbh698vwpk037yw27gd3nvwwzdv42jal2li"))))
      (inputs (list python-pypa-build python-hypothesis python-wheel
                    python-parameterized))
      (native-inputs (list python-pytest python-nose))
      (build-system pyproject-build-system)
      (arguments
       (list #:phases #~(modify-phases %standard-phases
                          (replace 'build
                            (lambda _
                              (setenv "SOURCE_DATE_EPOCH" "315532800")
                              (invoke "python"
                                      "-m"
                                      "build"
                                      "--wheel"
                                      "--no-isolation"
                                      ".")))
                          (replace 'install
                            (lambda* (#:key outputs #:allow-other-keys)
                              (let ((whl (car (find-files "dist" "\\.whl$"))))
                                (invoke "pip"
                                        "--no-cache-dir"
                                        "--no-input"
                                        "install"
                                        "--no-deps"
                                        "--prefix"
                                        #$output
                                        whl))))
                          (replace 'check
                            (lambda* (#:key tests? #:allow-other-keys)
                              (when tests?
                                (invoke "python" "test.py")))))))
      (home-page "https://github.com/wolever/pprintpp")
      (synopsis "Python pretty-printer")
      (description
       "This package is a printer for Python which pretty-prints structures.
It also attempts to print Unicode characters without escaping them.")
      (license license:bsd-3))))

(define-public python-pluggy-1.0
  (package
    (inherit python-pluggy)
    (name "python-pluggy")
    (version "1.0.0")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "pluggy" version))
              (sha256
               (base32
                "0n8iadlas2z1b4h0fc73b043c7iwfvx9rgvqm1azjmffmhxkf922"))))
    (inputs (list python-pypa-build python-wheel))
    (native-inputs (list python-pytest python-setuptools-scm))))

(define-public python-setuptools-scm-7
  (package
    (inherit python-setuptools-scm)
    (version "7.0.5")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "setuptools_scm" version))
              (sha256
               (base32
                "0i28zghzdzzkm9w8rrjwphggkfs58nh6xnqsjhmqjvqxfypi67h3"))))
    (build-system pyproject-build-system)
    (arguments
     `( ;Disabled tests to avoid extra dependencies.
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  ;; Disabled sanity check to avoid extra dependencies.
                  (delete 'sanity-check))))
    (propagated-inputs (list python-packaging-bootstrap python-tomli))))

(define-public python-pathspec-0.10.1
  (package
    (name "python-pathspec")
    (version "0.10.1")
    (source ;; (origin
     ;;   (method url-fetch)
     ;;   (uri (pypi-uri "pathspec" version))
     ;;   (sha256
     ;;    (base32
     ;;     "0g9jhhhf3zmrnvzvjjd2yhizsb6i93hmlszb09wixlr1nrhn3kks")))
     (origin
       (method git-fetch)
       (uri (git-reference
             (url
              "https://github.com/cpburnz/python-pathspec")
             (commit (string-append "v" version))))
       (sha256
        (base32 "0sgzh7ad1x098d0rln01f0qabpa7mnp26863isncbiyqsxh1gaxp"))))
    (build-system pyproject-build-system)
    (home-page "https://github.com/cpburnz/python-pathspec")
    (synopsis
     "Utility library for gitignore style pattern matching of file paths.")
    (description
     "Utility library for gitignore style pattern matching of file paths.")
    (license license:mpl2.0)))

;; This depends on packages in python-xyz.scm:
;; python-version, python-importlib-metadata, python-pathspec,
;; python-pluggy-1.0, and python-platformdirs.
(define-public python-hatchling
  (package
    (name "python-hatchling")
    (version "1.10.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/pypa/hatch")
                    (commit (string-append "hatchling-v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0ahx62w711a2vnb91ahqxrw8yi0gq0kfch3fk6akzngd13376czj"))))
    ;; python-pypa-build needed for bootstrapping.
    ;; Otherwise we get a circular reference:
    ;; python-hatchling trying to build itself, without
    ;; first having hatchling installed.
    (inputs (list python-editables
                  python-packaging-bootstrap
                  ;; Below from python-xyz.scm, can be moved to python-build.scm
                  python-pathspec-0.10.1
                  ;; Below from python-xyz.scm, can be moved to python-build.scm
                  python-pluggy-1.0
                  python-tomli))
    (build-system pyproject-build-system)
    (arguments
     `( ;Tests depend on module python-hatch, which would result in circular references
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  (replace 'build
                    (lambda _
                      (chdir "backend")
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "python"
                              "-m"
                              "build"
                              "--wheel"
                              "--no-isolation"
                              ".")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl)))))))
    (home-page "https://ofek.dev/projects/hatch/")
    (synopsis "Bootstrap binaries to build @code{python-hatch}")
    (description "Bootstrap binaries to build @code{python-hatch}")
    ;; MIT License
    (license license:expat)))

;; (define-public python-hatchling
;;     (package
;;     (name "python-hatchling")
;;     (version "1.10.0")
;;     (source (origin
;;               (method git-fetch)
;;               (uri (git-reference
;;                     (url "https://github.com/pypa/hatch")
;;                     (commit (string-append "hatchling-v" version))))
;;               (file-name (git-file-name name version))
;;               (sha256
;;                (base32
;;                 "0ahx62w711a2vnb91ahqxrw8yi0gq0kfch3fk6akzngd13376czj"))))
;;     (inputs (list python-editables
;;                   python-packaging-bootstrap
;;                   ;; Below from python-xyz.scm, can be moved to python-build.scm
;;                   python-pathspec-0.10.1
;;                   ;; Below from python-xyz.scm, can be moved to python-build.scm
;;                   python-pluggy-1.0
;;                   python-tomli
;;                   python-hatchling-bootstrap))
;;     (build-system pyproject-build-system)
;;     (arguments
;;      `( ;Tests depend on module python-hatch, which this
;;        ;; is bootstrapping.
;;        #:tests? #f
;;        #:phases (modify-phases %standard-phases
;;                   (replace 'build
;;                     (lambda _
;;                       (chdir "backend")
;;                       ;; ZIP does not support timestamps before 1980.
;;                       (setenv "SOURCE_DATE_EPOCH" "315532800")
;;                       (invoke "python"
;;                               "-m"
;;                               "build"
;;                               "--wheel"
;;                               "--no-isolation"
;;                               ".")))
;;                   (replace 'install
;;                     (lambda* (#:key outputs #:allow-other-keys)
;;                       (let ((whl (car (find-files "dist" "\\.whl$"))))
;;                         (invoke "pip"
;;                                 "--no-cache-dir"
;;                                 "--no-input"
;;                                 "install"
;;                                 "--no-deps"
;;                                 "--prefix"
;;                                 (assoc-ref %outputs "out")
;;                                 whl)))))))
;;     (home-page "https://ofek.dev/projects/hatch/")
;;     (synopsis "Bootstrap binaries to build @code{python-hatch}")
;;     (description "Bootstrap binaries to build @code{python-hatch}")
;;     ;; MIT License
;;     (license license:expat)))

(define-public python-hatch
  (package
    (name "python-hatch")
    (version "1.6.2") ;; at minimum 1.5.0
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/pypa/hatch")
                    (commit (string-append "hatch-v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0if5ssp6vlfvna1jcvap40r0f7pm45h7kbia78h5ivm17vb8p08b"
                ;;"030yi9hw50mn899pq073lw2a55r57skl2g9agjp3b4l95f3nay30"
                ))))
    (inputs (list python-pypa-build
                  python-editables
                  python-importlib-metadata
                  python-version
                  python-packaging-next
                  python-pathspec
                  python-pluggy-1.0 ;TODO: Not detected by pytest?
                  python-hatchling
                  python-tomli
                  python-platformdirs
                  python-rich
                  python-tomli-w))
    (build-system pyproject-build-system)
    (arguments
     `( ;Tests appear to be written such that the input python-pluggy-1.0 is
       ;; not detected.
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  (replace 'build
                    (lambda _
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "hatchling" "build")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl))))
                  (replace 'check
                    (lambda* (#:key tests? #:allow-other-keys)
                      (when tests?
                        (chdir "tests")
                        (invoke "pytest" "-vv"))))
                  ;; Can't have hatch as a requirement of itself.
                  (delete 'sanity-check))))
    (home-page "https://ofek.dev/projects/hatch/")
    (synopsis "Python build system with project generation")
    (description
     "Python build system with project generation.  It also defines a specific
syntax in @code{toml} files to check for dependencies.")
    ;; MIT License
    (license license:expat)))

(define-public python-hatch-vcs
  ;; Tags are not accurate; just use the commit itself.
  (let ((commit "367daedb23ba906f3e0714c64392fdd6ffa69ab2")
        (revision "1"))
    (package
      (name "python-hatch-vcs")
      (version (git-version "0.2.0" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/ofek/hatch-vcs")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "0nlnv32jqiz8ikc013h5simmiqqg0qa7pm0qcbd8yiqq1p43iw05"))))
      (build-system pyproject-build-system)
      (inputs (list python-pypa-build
                    python-pathspec-0.10.1
                    python-pluggy-1.0
                    python-editables
                    git
                    python-hatchling
                    ;; python-hatch
                    python-typing-extensions))
      (native-inputs (list python-pytest
                           ;; python-setuptools-scm-6.4 minimum
                           python-setuptools-scm-7))
      ;; (arguments
      ;;  (list #:phases #~(modify-phases %standard-phases
      ;;                     (replace 'build
      ;;                       (lambda _
      ;;                         (setenv "SOURCE_DATE_EPOCH" "315532800")
      ;;                         (invoke "python"
      ;;                                 "-m"
      ;;                                 "build"
      ;;                                 "--wheel"
      ;;                                 "--no-isolation"
      ;;                                 ".")))
      ;;                     (replace 'install
      ;;                       (lambda* (#:key outputs #:allow-other-keys)
      ;;                         (let ((whl (car (find-files "dist" "\\.whl$"))))
      ;;                           (invoke "pip"
      ;;                                   "--no-cache-dir"
      ;;                                   "--no-input"
      ;;                                   "install"
      ;;                                   "--no-deps"
      ;;                                   "--prefix"
      ;;                                   #$output
      ;;                                   whl))))
      ;;                     (replace 'check
      ;;                       (lambda* (#:key tests? #:allow-other-keys)
      ;;                         (when tests?
      ;;                           (invoke "pytest" "-vvv"))))))) ;)
      (arguments
     `( ;Tests depend on module python-hatch, which this
       ;; is bootstrapping.
       #:tests? #f
       #:phases (modify-phases %standard-phases
                  (replace 'build
                    (lambda _
                      ;;(chdir "backend")
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "python"
                              "-m"
                              "build"
                              "--wheel"
                              "--no-isolation"
                              ".")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl)))))))
      (home-page "https://ofek.dev/projects/hatch/")
      (synopsis "Plugin for @code{python-hatch} to include versions")
      (description
       "This plugin defines a version-control syntax for use with
@code{toml} files intended for use with @code{python-hatch}.")
      ;; MIT License
      (license license:expat))))

(define-public python-pytest-icdiff
  (package
    (name "python-pytest-icdiff")
    (version "0.6")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "pytest-icdiff" version))
              (sha256
               (base32
                "1b8vzn2hvv6x25w1s446q1rfsbdik617lzpal3qb94x8a12yzwg8"))))
    (build-system pyproject-build-system)
    (propagated-inputs (list python-pypa-build python-icdiff python-pprintpp
                             python-pluggy-1.0))
    (native-inputs (list python-pytest))
    (arguments
     `(;; Tests fail with "collecting ... collected 0 items"
       #:tests? #f))
    ;; (arguments
    ;;  `(#:phases
    ;;    (modify-phases %standard-phases
    ;;      (add-before 'check 'chdir-to-test-dir
    ;;        (chdir "tests")))))
    (home-page "https://github.com/hjwp/pytest-icdiff")
    (synopsis "Colored diffs using @code{python-icdiff} for pytest output")
    (description
     "This package uses @code{python-icdiff} to add color to the output of
pytest assertions.")
    (license (license:non-copyleft "LICENSE"))))

(define-public python-hatch-fancy-pypi-readme
  (package
    (name "python-hatch-fancy-pypi-readme")
    (version "22.8.0")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "hatch_fancy_pypi_readme" version))
              (sha256
               (base32
                ;; PyPI hash problem
                ;;"1ykfz1sbz58xbjw5k9xpmn5r6ji16w8vag47j8f969bqy3w52ikx"
                "0sn2wsfbpsbf2mqhjvw62h1cfy5mz3d7iqyqvs5c20cnl0n2i4fs"))))
    (build-system pyproject-build-system)
    (propagated-inputs (list python-tomli python-typing-extensions))
    (native-inputs (list python-pypa-build
                         python-pathspec-0.10.1
                         python-pluggy-1.0
                         python-editables
                         python-hatchling
                         python-wheel
                         python-pytest
                         python-pytest-icdiff))
    (arguments
     `(#:phases (modify-phases %standard-phases
                  (add-before 'build 'disable-broken-tests
                    (lambda _
                      ;; Skip the tests for "building". Guix already does this,
                      ;; so we don't need to test it for this package.
                      (chdir "tests")
                      (invoke "sed" "-i"
                              "11ipytest.skip('No need to test\
 building; guix does this already', allow_module_level=True)"
                              "test_end_to_end.py")
                      (chdir "../")))
                  ;; XXX: PEP 517 manual build/install procedures copied from
                  ;; python-isort.
                  (replace 'build
                    (lambda _
                      ;; ZIP does not support timestamps before 1980.
                      (setenv "SOURCE_DATE_EPOCH" "315532800")
                      (invoke "python"
                              "-m"
                              "build"
                              "--wheel"
                              "--no-isolation"
                              ".")))
                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((whl (car (find-files "dist" "\\.whl$"))))
                        (invoke "pip"
                                "--no-cache-dir"
                                "--no-input"
                                "install"
                                "--no-deps"
                                "--prefix"
                                (assoc-ref %outputs "out")
                                whl))))
                  (replace 'check
                    (lambda* (#:key tests? #:allow-other-keys)
                      (when tests?
                        (invoke "pytest" "-vv")))))))
    (home-page
     "https://github.com/hynek/hatch-fancy-pypi-readme")
    (synopsis "Syntax for styling PyPI READMEs")
    (description
     "Defines a syntax for the python-hatch build system, intended for styling
READMEs for PyPI.")
    ;; MIT License
    (license license:expat)))

;; Has to be done manually. DO NOT copy and paste this one.
(define-public python-jsonschema-4.15
  (package
    (inherit python-jsonschema-next)
    (version "4.16.0")
    (source (origin
              (method url-fetch)
              (uri (pypi-uri "jsonschema" version))
              (sha256
               (base32
                ;; PyPI hashing problem
                "08sbw5fn19vn8x7c216gkczyzd575702yx2vmqdrgxpgfvq5jl0n"
                ;;"07pyh8g4csapkfjgjww7vkxwvh1qwxwqxz82wm2b1kmxj69rgx11"
                ))))
    (native-inputs (list python-pypa-build
                         python-twisted
                         python-hatch
                         python-hatchling
                         python-pathspec-0.10.1
                         python-pluggy-1.0
                         python-editables
                         python-hatch-vcs
                         python-setuptools-scm-7
                         python-hatch-fancy-pypi-readme))
    (propagated-inputs (list python-attrs
                             python-importlib-metadata
                             python-pyrsistent
                             python-typing-extensions
                             python-hatch-vcs))
    (home-page "https://github.com/python-jsonschema/jsonschema")))

;;; OCaml
;; Requires python-jsonschema with version at minimum 4.6.0 to run
;; tests. 
;; See https://github.com/ahrefs/atd/issues/306 for more info on that.
(define-public ocaml-atd
  (package
    (name "ocaml-atd")
    (version "2.10.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/ahrefs/atd")
                    (commit version)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "10fgahdigrl01py0k0q2d6a60yps38q96dxhjnzm9jz4g931716l"))))
    (build-system dune-build-system)
    (arguments
     `(#:phases (modify-phases %standard-phases
                  (replace 'check
                    (lambda* (#:key tests? #:allow-other-keys)
                      ;; The dune-build-system does not run "make test" but
                      ;; "dune runtest test --release".
                      ;; This project, rather, needs us to run "make test".
                      ;;
                      ;; For this package (ocaml-atd), we DO NOT run all the
                      ;; tests. The atd repository has resources for several
                      ;; different interfaces (python, scala, etc), but we
                      ;; don't need to run those tests if we are just
                      ;; interested in the ocaml interface.
                      ;; So we stick with just the ocaml tests here.
                      (when tests?
                        (invoke "make" "test-ocaml")))))))
    (propagated-inputs (list ocaml-menhir
                             ocaml-easy-format
                             ocaml-odoc
                             ocaml-re
                             ocaml-camlp-streams
                             ocaml-biniou
                             ocaml-yojson
                             ocaml-cmdliner))
    (native-inputs (list ocaml-alcotest
                         python-pypa-build
                         python-jsonschema-4.15
                         python-flake8
                         python-mypy
                         python-pytest))
    (inputs (list python))
    (home-page "https://github.com/ahrefs/atd")
    (synopsis "Parser for the ATD data format description language")
    (description
     "ATD is an OCaml library providing a parser for the Adjustable Type
Definitions language.")
    ;; Modified BSD license
    (license (license:non-copyleft "LICENSE.md"))))

(define-public ocaml-elpi
  (package
    (name "ocaml-elpi")
    ;; For more information on which version works with Coq 8.16,
    ;; see the relevant issue:
    ;; https://github.com/math-comp/hierarchy-builder/issues/297
    ;; Here we use
    ;; coq-elpi 1.15.4 + ocaml-elpi 1.16.5 +
    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.16).
    ;; (version "1.15.2")
    ;;(version "1.16.5")
    (version "1.16.7")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/LPCIC/elpi")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                ;; for 1.16.5
                ;;"1l6grpglkvyyj0p01l0q5ih12lp4vizamgj7i63ig82gqpyzk9dl"
                ;; for the version that the patch is based on (1.16.7)
                "1i0731f7jj48zvkla959pffj5l0qynmfyxljgszc6z3b4lpni1xc"))
              ;; Fix incompatibility with ocaml-yojson@2.0.2.
              ;; See <https://github.com/LPCIC/elpi/pull/167>.
              (patches (search-patches "ocaml-elpi-fix-yojson.patch"))
              ;(patches '("/home/chips/home/code/guix_packages/built/patches/ocaml-elpi-fix-yojson.patch"))
              ))
    (build-system dune-build-system)
    (arguments
     `(#:test-target "tests"))
     ;; Build currently fails with error (repeated several times):
     ;; 'Warning 6 [labels-omitted: label argsdepth was omitted in the
    ;; application of this function.'
    (propagated-inputs (list ocaml-stdlib-shims
                             ocaml-ppxlib
                             ocaml-menhir
                             ocaml-re
                             ocaml-ppx-deriving
                             ocaml-atd
                             ocaml-camlp-streams
                             ocaml-biniou
                             ocaml-yojson))
    (native-inputs (list ocaml-ansiterminal ocaml-cmdliner time))
    (home-page "https://github.com/LPCIC/elpi")
    (synopsis "ELPI - Embeddable λProlog Interpreter")
    (description
     "ELPI is an extension language for OCaml.  It implements a variant of
λProlog enriched with Constraint Handling Rules, a programming language for
manipulating syntax trees with binders.

This package provides both a command line interpreter, elpi, and an OCaml
library with the same name.")
    (license license:lgpl2.1+)))

;;; Coq
(define-public coq-elpi
  (package
    (name "coq-elpi")
    (version "1.16.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/LPCIC/coq-elpi")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "18w899fcz4kzx7zyr7a0g4avclbm5f82g7kh76b9fy2s99jz6q5c"))))
    ;;(build-system gnu-build-system)
    (build-system ocaml-build-system)
    (propagated-inputs (list coq-core ocaml-elpi ocaml-zarith))
    (inputs (list python lua-5.1 coq-core coq-stdlib)) 
    (arguments
     `(#:test-target "test"
       ;; From the repo: "COQBIN=%{bin}%/" "ELPIDIR=%{prefix}%/lib/elpi" "OCAMLWARN="
       #:make-flags ,#~(list (string-append "COQBIN="
                                            #$(this-package-input "coq-core")
                                            "/bin/")
                             (string-append "ELPIDIR="
                                            #$(this-package-input "ocaml-elpi")
                                            "/lib/ocaml/site-lib/elpi")
                             (string-append "COQLIBINSTALL="
                                            #$output
                                            "/lib/coq/user-contrib")
                             (string-append "COQMF_COQLIB="
                                            #$output
                                            "/lib/ocaml/site-lib/coq")
                             (string-append "COQPLUGININSTALL="
                                            #$output
                                            "/lib/ocaml/site-lib")
                             "OCAMLWARN=")
       #:phases (modify-phases %standard-phases
                  (delete 'configure)
                  #;(add-after 'check 'check-findlib-path
                    (lambda _
                      (invoke "ocamlfind" "query" "coq-elpi"))))))
    (home-page "https://github.com/LPCIC/coq-elpi")
    (synopsis "Elpi extension language for Coq")
    (description
     "Coq-elpi provides a Coq plugin that embeds ELPI, an extension language
for OCaml that is an implementation of λProlog.  It also provides a way to
embed Coq's terms into λProlog using the Higher-Order Abstract Syntax approach
and a way to read terms back.  In addition to that it exports to ELPI a set of
Coq's primitives.  Finally it provides a way to define new vernacular commands
and new tactics.")
    (license license:lgpl2.1)))

(define-public coq-mathcomp-hierarchy-builder
  (package
    (name "coq-mathcomp-hierarchy-builder")
    ;; For more information on which version works with Coq 8.16,
    ;; see the relevant issue:
    ;; https://github.com/math-comp/hierarchy-builder/issues/297
    ;; Here we use
    ;; coq-elpi 1.15.4 + ocaml-elpi 1.16.5 +
    ;; coq-mathcomp-hierarchy-builder 1.3.0 (Coq 8.16)
    ;;(version "1.3.0")
    (version "1.4.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/math-comp/hierarchy-builder")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                ;; 1.3.0
                ;;"17k7rlxdx43qda6i1yafpgc64na8br285cb0mbxy5wryafcdrkrc"
                ;; 1.4.0
                "1g7narbx5n8bbnnnn8kmgk62clah9fsy9jb154xcr41p8psrvrxl"))))
    ;;(build-system ocaml-build-system) ;; fails for same reason as dune.
    (build-system gnu-build-system)
    (arguments
     `(#:make-flags ,#~(list (string-append "ELPIDIR="
                                            #$(this-package-input "coq-elpi")
                                            "/lib/coq/user-contrib/elpi/")
                             (string-append "DESTDIR="
                                            (assoc-ref %outputs "out"))
                             (string-append "COQLIBINSTALL="
                                            #$output
                                            "/lib/coq/user-contrib"))
       #:test-target "test-suite"
       #:phases (modify-phases %standard-phases
                  (delete 'configure)
                  )))
    (propagated-inputs (list coq-elpi))
    (inputs (list coq-core
                  coq-stdlib))
    (native-inputs (list ocaml which))
    (synopsis "Hierarchy structures for the Coq proof assistant")
    (description
     "Hierarchy Builder (HB) provides high level commands to declare a
hierarchy of interfaces for the Coq system.

Given a structure one can develop its theory, and that theory becomes
applicable to all examples of the structure.  One can also declare alternative
interfaces, for convenience or backward compatibility, and provide glue code
linking these interfaces to the structures part of the hierarchy.")
    (home-page "https://math-comp.github.io/")
    ;; MIT license
    (license license:expat)))

(define-public coq-mathcomp-analysis
  (package
    (name "coq-mathcomp-analysis")
    (version "0.5.4")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/math-comp/analysis")
                    (commit version)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1l1yaxbmqr4li8x7g51q98a6v383dnf94lw1b74ccpwqz9qybz9m"))))
    (build-system gnu-build-system)
    (arguments
     `( ;No rule to make target 'check'. Stop.
       ;; Makefile.common has no references to tests.
       ;; There are also no references to tests found after
       ;; running the following commands in the top
       ;; directory of the cloned repo:
       ;; find -type d | grep -i test
       ;; rg test # where rg is ripgrep
       ;; Checking the git log, we find: "Add test suite for
       ;; joins and several fixes".
       ;;
       ;; If tests are included, this quote suggests that they
       ;; would be part of the source files themselves,
       ;; and the tests would be run as part of the build
       ;; process.
       #:tests? #f
       #:make-flags ,#~(list (string-append "COQBIN="
                                            #$(this-package-input "coq-core")
                                            "/bin/")
                             (string-append "COQBININSTALL="
                                            (assoc-ref %outputs "out") "/bin/")
                             (string-append "COQMF_COQLIB="
                                            (assoc-ref %outputs "out")
                                            "/lib/ocaml/site-lib/coq")
                             (string-append "COQLIBINSTALL="
                                            (assoc-ref %outputs "out")
                                            "/lib/coq/user-contrib"))
       #:phases (modify-phases %standard-phases
                  (delete 'configure)
                  (replace 'build
                    (lambda* (#:key make-flags #:allow-other-keys)
                      (apply invoke "make" "build" make-flags))))))
    (inputs (list coq
                  coq-stdlib
                  coq-mathcomp
                  coq-mathcomp-finmap
                  coq-mathcomp-hierarchy-builder
                  coq-elpi
                  coq-mathcomp-bigenough
                  coq-core))
    (native-inputs (list ocaml which))
    (synopsis "Real analysis for the Coq proof assistant")
    (description
     "This repository contains an experimental library for real analysis for
the Coq proof-assistant, using the Mathematical Components library.")
    (home-page "https://math-comp.github.io/")
    (license license:cecill-c)))

coq-mathcomp-analysis

[bug#58310] Manifest for coq-mathcomp-analysis

[Garek Dyszel via Guix-patches via]

I'm in UTC-0400, so your first email arrived in my inbox at around
04:00. Sorry I didn't see these!

At 10:17 2022-11-13 UTC+0100, Julien Lepiller wrote:
>> I tried building your file (it's technically not a manifest) and
>> indeed it's failing in the chack-findlib-path.

You're right that it's not a manifest. I had put a (packages->manifest)
invocation at the end of the file to see why coq-elpi wasn't building.
Later I just threw a package at the end when testing it later, and
forgot that the file then became a package file.

>> Why do you want to run it?

I knew that ocamlfind wasn't able to find the file coq-elpi.elpi when
building coq-mathcomp-hierarchy-builder. I was trying to test for the
presence of that file...

>> There's no way it could work at this point, right after the check
>> phase, since the package is not even installed yet.

...and I thought that the phase 'check' came after the phase 'install'
for some reason :/

>> Also, the OCAMLPATH that would allow findlib to find it is not set to
>> the outputs, only to the inputs.

Looks like I'll need to take a closer look at ocaml-build-system!

At 11:53 2022-11-13 UTC+0100, Julien Lepiller wrote:
> So, I've had a further look at the sources for the failing packages
> and figured that some variables were missing in the make-flags.

Tweaking the make-flags is exactly what's been occupying my time for the
last few months off and on, yep :)

> Attached is the fixed version of your file that builds
> coq-mathcomp-analysis.

Wow! Thanks so much! I can finally move to using it instead of building
it, although trying to get it to build was still a lot of fun :)

> Note that the build of mathcomp-analysis is
> very quiet and takes a long time, but it works eventually.

For anybody else who might be reading this thread, it took about 12
minutes to build on my system. I ran 'guix gc' beforehand to get an
accurate number:
$ until guix gc && time guix build -Kf coq-mathcomp-analysis.scm;\
$ do sleep 0.1; done
...

real	11m18.769s
user	0m7.332s
sys	0m0.490s

Out of curiosity, where did you put the patch file so that (patches
(search-patches "ocaml-elpi-fix-yojson.patch")) worked? My system throws
this error, so I had to switch the patch's path back: "guix build:
error: ocaml-elpi-fix-yojson.patch: patch not found".

[bug#58310] Manifest for coq-mathcomp-analysis

[Julien Lepiller]

[-- Attachment #1: Type: text/plain, Size: 2821 bytes --]

There's a trick for patches: they are loaded from the search path, so you can add the file to any empty directory and add that directory to the load path.

For instance, if you have ~/guix-patches/my.patch, then you can build a package that looks for my.patch with:

guix build -L ~/guix-patches

Le 13 novembre 2022 19:54:03 GMT+01:00, Garek Dyszel <garekdyszel@disroot.org> a écrit :
>I'm in UTC-0400, so your first email arrived in my inbox at around
>04:00. Sorry I didn't see these!
>
>At 10:17 2022-11-13 UTC+0100, Julien Lepiller wrote:
>>> I tried building your file (it's technically not a manifest) and
>>> indeed it's failing in the chack-findlib-path.
>
>You're right that it's not a manifest. I had put a (packages->manifest)
>invocation at the end of the file to see why coq-elpi wasn't building.
>Later I just threw a package at the end when testing it later, and
>forgot that the file then became a package file.
>
>>> Why do you want to run it?
>
>I knew that ocamlfind wasn't able to find the file coq-elpi.elpi when
>building coq-mathcomp-hierarchy-builder. I was trying to test for the
>presence of that file...
>
>>> There's no way it could work at this point, right after the check
>>> phase, since the package is not even installed yet.
>
>...and I thought that the phase 'check' came after the phase 'install'
>for some reason :/
>
>>> Also, the OCAMLPATH that would allow findlib to find it is not set to
>>> the outputs, only to the inputs.
>
>Looks like I'll need to take a closer look at ocaml-build-system!
>
>At 11:53 2022-11-13 UTC+0100, Julien Lepiller wrote:
>> So, I've had a further look at the sources for the failing packages
>> and figured that some variables were missing in the make-flags.
>
>Tweaking the make-flags is exactly what's been occupying my time for the
>last few months off and on, yep :)
>
>> Attached is the fixed version of your file that builds
>> coq-mathcomp-analysis.
>
>Wow! Thanks so much! I can finally move to using it instead of building
>it, although trying to get it to build was still a lot of fun :)
>
>> Note that the build of mathcomp-analysis is
>> very quiet and takes a long time, but it works eventually.
>
>For anybody else who might be reading this thread, it took about 12
>minutes to build on my system. I ran 'guix gc' beforehand to get an
>accurate number:
>$ until guix gc && time guix build -Kf coq-mathcomp-analysis.scm;\
>$ do sleep 0.1; done
>...
>
>real	11m18.769s
>user	0m7.332s
>sys	0m0.490s
>
>Out of curiosity, where did you put the patch file so that (patches
>(search-patches "ocaml-elpi-fix-yojson.patch")) worked? My system throws
>this error, so I had to switch the patch's path back: "guix build:
>error: ocaml-elpi-fix-yojson.patch: patch not found".
>

[-- Attachment #2: Type: text/html, Size: 4568 bytes --]